//while-condition -> expression declaration
ExpressionPtr Parser::parseConditionExpression()
{
Token token;
expect_next(token);
if(token.type == TokenType::Identifier && token.identifier.keyword != Keyword::_)
{
Keyword::T keyword = token.identifier.keyword;
tassert(token, keyword == Keyword::Var || keyword == Keyword::Let, Errors::E_EXPECTED_EXPRESSION_VAR_OR_LET_IN_A_CONDITION_1, L"if");
ValueBindingPatternPtr value = nodeFactory->createValueBindingPattern(token.state);
value->setReadOnly(keyword == Keyword::Let);
PatternPtr binding = parsePattern();
value->setBinding(binding);
if(binding->getNodeType() == NodeType::TypedPattern)
{
TypedPatternPtr tpattern = std::static_pointer_cast<TypedPattern>(binding);
value->setBinding(tpattern->getPattern());
value->setDeclaredType(tpattern->getDeclaredType());
}
if (!match(L"=", token))
{
tassert(token, false, Errors::E_VARIABLE_BINDING_IN_A_CONDITION_REQUIRES_AN_INITIALIZER);
}
AssignmentPtr assignment = nodeFactory->createAssignment(token.state);
ExpressionPtr expr = parseExpression();
assignment->setLHS(value);
assignment->setRHS(expr);
return assignment;
}
else
{
restore(token);
return parseExpression();
}
}
void SemanticAnalyzer::visitValueBinding(const ValueBindingPtr& node)
{
PatternPtr name = node->getName();
//tuple was already exploded in declaration analyzer
if(name->getNodeType() == NodeType::Tuple)
{
validateTupleTypeDeclaration(node);
}
if (name->getNodeType() != NodeType::Identifier)
return;
if(node->getOwner()->isReadOnly() && !node->getInitializer() && ctx->currentType == nullptr)
{
error(node, Errors::E_LET_REQUIRES_INITIALIZER);
return;
}
//handle type inference for temporary variable
if(node->isTemporary() && node->getInitializer())
{
//temporary variable always has an initializer
TypePtr initializerType;
TypePtr declaredType = node->getType();
SCOPED_SET(ctx->contextualType, declaredType);
node->getInitializer()->accept(this);
initializerType = node->getInitializer()->getType();
assert(initializerType != nullptr);
if(declaredType)
{
//it has both type definition and initializer, then we need to check if the initializer expression matches the type annotation
if(!initializerType->canAssignTo(declaredType))
{
error(node, Errors::E_CANNOT_CONVERT_EXPRESSION_TYPE_2, initializerType->toString(), declaredType->toString());
return;
}
}
else
{
node->setType(initializerType);
}
}
//add implicitly constructor for Optional
IdentifierPtr id = static_pointer_cast<Identifier>(node->getName());
SymbolScope* currentScope = symbolRegistry->getCurrentScope();
TypePtr declaredType = node->getType() ? node->getType() : lookupType(node->getDeclaredType());
SCOPED_SET(ctx->contextualType, declaredType);
if(!declaredType && !node->getInitializer())
{
error(node, Errors::E_TYPE_ANNOTATION_MISSING_IN_PATTERN);
return;
}
SymbolPtr sym = currentScope->lookup(id->getIdentifier());
assert(sym != nullptr);
SymbolPlaceHolderPtr placeholder = std::dynamic_pointer_cast<SymbolPlaceHolder>(sym);
assert(placeholder != nullptr);
if(declaredType)
{
placeholder->setType(declaredType);
}
ExpressionPtr initializer = node->getInitializer();
if(initializer)
{
placeholder->setFlags(SymbolFlagInitializing, true);
ExpressionPtr initializer = transformExpression(declaredType, node->getInitializer());
node->setInitializer(initializer);
TypePtr actualType = initializer->getType();
assert(actualType != nullptr);
if(declaredType)
{
if(!Type::equals(actualType, declaredType) && !canConvertTo(initializer, declaredType))
{
error(initializer, Errors::E_CANNOT_CONVERT_EXPRESSION_TYPE_2, actualType->toString(), declaredType->toString());
return;
}
}
if(!declaredType)
placeholder->setType(actualType);
}
assert(placeholder->getType() != nullptr);
placeholder->setFlags(SymbolFlagInitializing, false);
//optional type always considered initialized, compiler will make it has a default value nil
TypePtr symbolType = sym->getType();
GlobalScope* global = symbolRegistry->getGlobalScope();
if(initializer || global->isOptional(symbolType) || global->isImplicitlyUnwrappedOptional(symbolType))
markInitialized(placeholder);
if (initializer)
placeholder->setFlags(SymbolFlagHasInitializer, true);
if(node->isTemporary())
{
placeholder->setFlags(SymbolFlagTemporary, true);
markInitialized(placeholder);
}
if(!node->isTemporary())
{
//check access control level
DeclarationType decl = ctx->currentType ? DeclarationTypeProperty : DeclarationTypeVariable;
declarationAnalyzer->verifyAccessLevel(node->getOwner(), placeholder->getType(), decl, ComponentTypeType);
}
if(ctx->currentType && ctx->currentType->getCategory() == Type::Protocol)
{
error(node, Errors::E_PROTOCOL_VAR_MUST_BE_COMPUTED_PROPERTY_1);
}
}
void SemanticAnalyzer::validateTupleTypeDeclaration(const PatternPtr& name, const TypePtr& declType, const TypePtr& initType)
{
switch(name->getNodeType())
{
case NodeType::Identifier:
{
if(initType && declType && !initType->canAssignTo(declType))
{
error(name, Errors::E_CANNOT_CONVERT_EXPRESSION_TYPE_2, initType->toString(), declType->toString());
}
break;
}
case NodeType::TypedPattern:
{
TypedPatternPtr pat = static_pointer_cast<TypedPattern>(name);
assert(pat->getDeclaredType());
TypePtr nameType = lookupType(pat->getDeclaredType());
assert(nameType != nullptr);
if(declType && !Type::equals(nameType, declType))
{
error(name, Errors::E_TYPE_ANNOTATION_DOES_NOT_MATCH_CONTEXTUAL_TYPE_A_1, declType->toString());
abort();
return;
}
break;
}
case NodeType::Tuple:
{
TuplePtr tuple = static_pointer_cast<Tuple>(name);
if(declType)
{
if((declType->getCategory() != Type::Tuple) || (tuple->numElements() != declType->numElementTypes()))
{
error(name, Errors::E_TYPE_ANNOTATION_DOES_NOT_MATCH_CONTEXTUAL_TYPE_A_1, declType->toString());
abort();
return;
}
}
int elements = tuple->numElements();
for(int i = 0; i < elements; i++)
{
PatternPtr element = tuple->getElement(i);
TypePtr elementDecl = declType ? declType->getElementType(i) : nullptr;
TypePtr elementInit = initType ? initType->getElementType(i) : nullptr;
validateTupleTypeDeclaration(element, elementDecl, elementInit);
}
break;
}
case NodeType::ValueBindingPattern:
break;
case NodeType::EnumCasePattern:
{
break;
}
case NodeType::TypeCase:
case NodeType::TypeCheck:
default:
error(name, Errors::E_EXPECT_TUPLE_OR_IDENTIFIER);
break;
}
}
