public void Visit(DispatchExpNode node)
{
node.initDis.Accept(this);
if (node.initType.Text == "Object")
{
node.initType = new TypeNode(node.initDis.line, node.initDis.column, node.initDis.staticType.Text);
}
if (!scope.IsDefinedType(node.initType.Text, out TypeInfo typeSuperClass))
{
errors.Add(ErrorSemantic.NotDeclaredType(node.initType));
}
if (!(node.initDis.staticType <= typeSuperClass))
{
errors.Add(ErrorSemantic.CannotConvert(node, node.initDis.staticType, typeSuperClass));
}
node.paramFormal.ForEach(x => x.Accept(this));
var scopeSuperClass = typeSuperClass.ClassReference.Scope;
if (!(scopeSuperClass.IsDefined(node.Id.text, node.paramFormal.Select(x => x.staticType).ToArray(), out node.staticType)))
{
errors.Add(ErrorSemantic.NotDeclareFunction(node, node.Id.text));
}
}
public void Visit(MethodNode node)
{
var scopeMethod = scope.CreateChild();
foreach (var arg in node.paramsFormal)
{
if (!scope.IsDefinedType(arg.type.Text, out TypeInfo typeArg))
{
errors.Add(ErrorSemantic.NotDeclaredType(arg.type));
}
scopeMethod.Define(arg.id.text, typeArg);
}
if (!scope.IsDefinedType(node.return_type.Text, out TypeInfo type))
{
errors.Add(ErrorSemantic.NotDeclaredType(node.return_type));
}
scope.Define(node.id.text, node.paramsFormal.Select(x => scope.GetType(x.type.Text)).ToArray(), type);
node.body_expr.Accept(new SemanticVisit(errors, scopeMethod));
if (!(node.body_expr.staticType <= type))
{
errors.Add(ErrorSemantic.CannotConvert(node.body_expr, node.body_expr.staticType, type));
}
node.return_type = new TypeNode(node.body_expr.line, node.body_expr.column, type.Text);
}
public void Visit(LetInNode node)
{
var scopeLet = scope.CreateChild();
foreach (var expInit in node.propertyLet)
{
expInit.expr_body.Accept(new SemanticVisit(errors, scopeLet));
var typeAssignExp = expInit.expr_body.staticType;
if (!scopeLet.IsDefinedType(expInit.formal.type.Text, out TypeInfo typeDeclared))
{
errors.Add(ErrorSemantic.NotDeclaredType(expInit.formal.type));
}
if (!(typeAssignExp <= typeDeclared))
{
errors.Add(ErrorSemantic.CannotConvert(expInit.formal.type, typeAssignExp, typeDeclared));
}
if (scopeLet.IsDefined(expInit.formal.id.text, out TypeInfo typeOld))
{
scopeLet.UpdateType(expInit.formal.id.text, typeDeclared);
}
else
{
scopeLet.Define(expInit.formal.id.text, typeDeclared);
}
}
node.exprBody.Accept(new SemanticVisit(errors, scopeLet));
node.staticType = node.exprBody.staticType;
}
public void Visit(ConditionalNode node)
{
node.If.Accept(this);
node.Then.Accept(this);
node.Else.Accept(this);
if (node.If.staticType.Text != "Bool")
{
errors.Add(ErrorSemantic.CannotConvert(node.If, node.If.staticType, scope.GetType("Bool")));
}
node.staticType = SemanticAlgorithm.LowerCommonAncestor(node.Then.staticType, node.Else.staticType);
}
public void Visit(WhileNode node)
{
node.condition.Accept(this);
node.loop_body.Accept(this);
if (node.condition.staticType.Text != "Bool")
{
errors.Add(ErrorSemantic.CannotConvert(node.condition, node.condition.staticType, scope.GetType("Bool")));
}
if (!scope.IsDefinedType("Object", out node.staticType))
{
errors.Add(ErrorSemantic.NotDeclaredType(new TypeNode(node.line, node.column, "Object")));
}
}
public void Visit(AssignNode node)
{
node.exprBody.Accept(this);
if (!scope.IsDefined(node.Id.text, out TypeInfo type))
{
errors.Add(ErrorSemantic.NotDeclaredVariable(node.Id));
}
if (!(node.exprBody.staticType <= type))
{
errors.Add(ErrorSemantic.CannotConvert(node, node.exprBody.staticType, type));
}
node.staticType = node.exprBody.staticType;
}
public void Visit(PropertyNode node)
{
node.expr_body.Accept(this);
var typebodyExpr = node.expr_body.staticType;
if (!scope.IsDefinedType(node.formal.type.Text, out TypeInfo typeDeclared))
{
errors.Add(ErrorSemantic.NotDeclaredType(node.formal.type));
}
if (!(typebodyExpr <= typeDeclared))
{
errors.Add(ErrorSemantic.CannotConvert(node.formal.type, typebodyExpr, typeDeclared));
}
scope.Define(node.formal.id.text, typeDeclared);
}