public void ParseMethodBody()
{
TypeBodyParser parser = new TypeBodyParser();
const string input = @"
int GetValue(int someValue, System.Collections.Generic.Dictionary<int, UnityEngine.Vector3> dict) {
var f;
int localVar = 4;
string str;
return someValue;
}
";
TypeBodyNode astNode = parser.Parse(input, "", 0);
Assert.AreEqual(1, astNode.nodes.size);
MethodNode methodNode = (MethodNode)astNode.nodes[0];
Assert.AreEqual(4, methodNode.body.statements.size);
Assert.IsInstanceOf <LocalVariableNode>(methodNode.body.statements[0]);
Assert.IsInstanceOf <LocalVariableNode>(methodNode.body.statements[1]);
Assert.IsInstanceOf <LocalVariableNode>(methodNode.body.statements[2]);
Assert.IsInstanceOf <ReturnStatementNode>(methodNode.body.statements[3]);
LocalVariableNode f = (LocalVariableNode)methodNode.body.statements[0];
LocalVariableNode localVar = (LocalVariableNode)methodNode.body.statements[1];
LocalVariableNode str = (LocalVariableNode)methodNode.body.statements[2];
ReturnStatementNode retn = (ReturnStatementNode)methodNode.body.statements[3];
Assert.AreEqual("f", f.name);
Assert.AreEqual(default, f.typeLookup.typeName);
public override dynamic Visit(ReturnStatementNode node)
{
node.Expression = Replace(node.Expression);
node.Expression.Accept(this);
return(null);
}
public override void Visit(ReturnStatementNode node)
{
Console.WriteLine(this.indentation + "return ---- Statement ----");
indentation = indentation + " ";
node.expression.Accept(this);
indentation = indentation.Substring(0, indentation.Length - 3);
}
private Statement BindReturnStatement(ReturnStatementNode syntax)
{
if (Function == null)
{
diagnostics.ReportInvalidReturn(syntax.ReturnToken);
return(new InvalidStatement());
}
var expression = syntax.Expression == null ? null : BindExpression(syntax.Expression);
var expressionType = expression?.Type ?? BuiltinTypes.Void;
if (expressionType != Function.Type)
{
if (expression == null)
{
diagnostics.ReportInconsistentReturnType(syntax.ReturnToken, Function, Function.Type, expressionType);
}
else
{
expression = BindConversion(syntax.Expression, expression, Function.Type, noDiagnostics: true);
if (expression is InvalidExpression)
{
diagnostics.ReportInconsistentReturnType(syntax.ReturnToken, Function, Function.Type, expressionType);
}
}
}
return(new ReturnStatement(Scope, expression));
}
public void genReturnStatement(ReturnStatementNode stmt)
{
if (stmt.retval != null)
{
genExpression(stmt.retval);
assembly.addLine("pop eax"); //eax <--- return val
}
}
protected override Boolean handleReturn(ReturnStatementNode returnStatement, HashSet <StatementNode> visited)
{
if (returnStatement.Value != null)
{
expressionChecker.handleExpression(returnStatement.Value, null, true);
}
return(Boolean.FALSE);
}
protected override Void handleReturn(ReturnStatementNode returnStatement, Set <TypeInfo> dependencies)
{
if (returnStatement.Value != null)
{
expressionHandler.handleExpression(returnStatement.Value, dependencies, true);
}
return(null);
}
private ReturnStatementNode BuildReturnStatementNode(LexSpan lex)
{
var res = new ReturnStatementNode();
res.AddNode(new ReturnToken(lex));
return(res);
}
/// <summary>
/// 返回语句
/// </summary>
/// <param name="node"></param>
public void Visit(ReturnStatementNode node)
{
var builder = new StringBuilder();
builder.AppendLine("返回语句:");
Console.WriteLine(builder.ToString());
Visit((Object)node.ValueExpression);
}
/// <summary>
/// Visits the Return Statement node.
/// </summary>
/// <param name="node">The node to visit.</param>
public virtual TResult VisitReturnStatement(ReturnStatementNode node)
{
if (node.Expression != null)
{
node.Expression.Accept(this);
}
return(default(TResult)); // The default naive implementation
}
private ReturnStatementNode BuildReturnStatementNode(LexSpan lex, SyntaxNodeOrToken node)
{
var res = new ReturnStatementNode();
res.AddNode(new ReturnToken(lex));
res.AddNode(node);
return(res);
}
public override dynamic Visit(ReturnStatementNode node)
{
CurrentBlock.Child = null;
CurrentBlock.AddStatement(node);
CurrentBlock.Returned = true;
return(null);
}
public Node ReturnStatement()
{
var return_node = new ReturnStatementNode()
{
AnchorToken = Expect(TokenCategory.RETURN)
};
return_node.Add(Optional(firstOfExpression, Expression));
Expect(TokenCategory.SEMICOLON);
return(return_node);
}
public override List <Expression> VisitReturnStatement(ReturnStatementNode node)
{
if (this.HasReturned)
{
throw (new SemanticCodeGenerationException(CodeGenerationErrors.CodeAfterReturnStatement)).SetErrorLocation(node);
}
this.HasReturned = true;
this.Expressions.Add(this.Context.Return(node.Expression.Accept(new ExpressionVisitor(this))));
return(this.Expressions);
}
private void Write(ReturnStatementNode stmt, bool notlambda = true)
{
if (notlambda)
{
Fill();
_code.Append("return ");
}
if (stmt.Children.Any())
{
Write(stmt.Children[0]);
}
}
private void EmitReturnStatement(ReturnStatementNode returnStatement)
{
output.Append("return");
if (returnStatement.ReturnExpressionNode != null)
{
output.Append(' ');
EmitExpression(returnStatement.ReturnExpressionNode);
}
output.Append(';');
}
public virtual Value evaluate(Context cx, ReturnStatementNode node)
{
output("<ReturnStatementNode position=\"" + node.pos() + "\">");
indent_Renamed_Field++;
if (node.expr != null)
{
node.expr.evaluate(cx, this);
}
indent_Renamed_Field--;
output("</ReturnStatementNode>");
return(null);
}
protected override List <AssemblyElement> VisitReturnStatement(ReturnStatementNode node)
{
List <AssemblyElement> instructions = new List <AssemblyElement>();
if (node.ExpressionNode != null)
{
instructions.AddRange(Visit(node.ExpressionNode));
}
instructions.Add(new Ret());
return(instructions);
}
private static PythonNode Wrap(ReturnStatement stmt, PythonNode parent)
{
var result = new ReturnStatementNode(stmt)
{
Parent = parent
};
if (stmt.Expression != null)
{
result.AddChild(Wrap(stmt.Expression, result));
}
return(result);
}
public void Visit(ReturnStatementNode node)
{
Cell cell = sender.GetCurrentCell();
Symbol state = Stbl.st.Retrieve(node.Identifier.Label);
if (state is StateSymbol s)
{
sender.SetCell(cell, s.Copy());
}
else
{
throw new TheLanguageErrorException($"Return statement. Unexpected type { state } expected State");
}
sender.ReturnStatementHasBeenHit = true;
}
public void Visit(ReturnStatementNode node)
{
bool returnsSomething = node.Count() != 0;
string procedureName = currentScope;
Type returnType = procedureTable[procedureName].type;
if (returnsSomething)
{
Visit((dynamic)node[0]);
}
else
{
string defaultValue = GetTypeDefaultCilValue(returnType);
builder.AppendLine($"\t\t{defaultValue}");
}
builder.AppendLine("\t\tret");
}
public Type Visit(ReturnStatementNode node)
{
if (currentScope == "")
{
throw new SemanticError("Unexpected return statement",
node.AnchorToken);
}
Type type = node.Count() == 0 ? Type.VOID : Visit((dynamic)node[0]);
var procedureType = procedureTable[currentScope].type;
if (!procedureType.CompatibleWith(type))
{
throw new SemanticError($"Invalid return type {type} for procedure of type {procedureType}",
node.AnchorToken);
}
return(type);
}
protected override Void handleReturn(ReturnStatementNode returnStatement, Void source)
{
var returnType = context.CodeValidationContext.CurrentMethod.ReturnType;
if (returnType == null)
{
if (returnStatement.Value != null)
{
this.ExpressionValidator.handleExpression(returnStatement.Value, null, true);
var rinfo = returnStatement.Value.getUserData(typeof(ExpressionInfo));
if (rinfo == null)
{
context.CodeValidationContext.LambdaReturnTypes.add(null);
}
else
{
context.CodeValidationContext.LambdaReturnTypes.add(ValidationHelper.getType(context, returnStatement.Value));
}
}
}
else if (returnType == context.TypeSystem.VoidType)
{
if (returnStatement.Value != null)
{
context.addError(CompileErrorId.ReturnVoid, returnStatement);
}
}
else if (returnStatement.Value == null)
{
context.addError(CompileErrorId.ReturnNotVoid, returnStatement);
}
else
{
this.ExpressionValidator.handleExpression(returnStatement.Value, returnType, true);
ValidationHelper.setBoxing(context, returnType, returnStatement.Value);
if (!ValidationHelper.isAssignable(context, returnType, returnStatement.Value))
{
var vinfo = returnStatement.Value.getUserData(typeof(ExpressionInfo));
context.addError(CompileErrorId.NoImplicitConversion, returnStatement.Value,
BytecodeHelper.getDisplayName((vinfo == null) ? null : vinfo.Type),
BytecodeHelper.getDisplayName(returnType));
}
}
return(null);
}
protected virtual ReturnStatementNode ParseReturnStatement(IStatementParentNode parent, ReturnOperatorToken returnOperator)
{
// PARSE: <return statement> ::= returnOperator <expression>
// Also: <statements> ::= <return statement> [’.’]
ReturnStatementNode result = new ReturnStatementNode(parent, returnOperator);
Token token = this.GetNextTokenxx(Preference.NegativeSign);
ExpressionNode expression = this.ParseExpression(result, token);
if (expression == null)
{
this.ReportParserError(result, SemanticErrors.MissingExpression, token);
}
SpecialCharacterToken period = null;
token = this.GetNextTokenxx(Preference.Default);
if (Parser.IsStatementDelimiter(token))
{
period = (SpecialCharacterToken)token;
token = this.GetNextTokenxx(Preference.Default);
}
result.SetContents(expression, period);
// Returns statement ... should have reached the end of the statement.
this.ResidueToken = token;
if (token is EofToken)
{
return(result); // OK
}
else if (Parser.IsBlockEndDelimiter(token))
{
return(result); // OK;
}
else if (Parser.IsStatementDelimiter(token))
{
this.ReportParserError(result, SemanticErrors.MissingStatement, token);
}
else
{
this.ReportParserError(result, SemanticErrors.CodeAfterReturnStatement, token);
}
return(result);
}
/// <summary>
/// Visits the Return Statement node.
/// </summary>
/// <param name="node">The node to visit.</param>
public override bool VisitReturnStatement(ReturnStatementNode node)
{
if (node.Parent == null)
{
return(false);
}
if (node.Token == null)
{
return(false);
}
if ((node.Expression == null) || !node.Expression.Accept(this))
{
return(false);
}
return(true);
}
public override void Visit(ReturnStatementNode node)
{
try
{
node.expression.Accept(this);
if (node.expression.ExpressionType.GetType() == typeof(ClassType) && !IsClassCompatible((ClassType)node.expression.ExpressionType, (ClassType)MethodBeingVisited.ReturnType))
{
throw new Exception("Return Expression should have compatible Type as in the Method Declaration!");
}
else
if (!AreTypeCompatible(node.expression.ExpressionType.GetType(), MethodBeingVisited.ReturnType.GetType()))
{
throw new Exception("Return Expression should have compatible Type as in the Method Declaration!");
}
}
catch (Exception e)
{
Analysis.LogSemanticError(e.Message, node.lineNumber);
}
}
public override dynamic Visit(ReturnStatementNode node)
{
var currentNode = (IdNode)FunctionStack.Peek();
var id = currentNode.Id.Accept(this);
node.Expression.Accept(this);
var type = currentNode.Type;
var expressionType = node.Expression.Type.PrimitiveType;
var expressionSubType = node.Expression.Type is ArrayTypeNode eat ? eat.SubType : PrimitiveType.Void;
if (!(node.Expression is NoOpNode) && currentNode.Type.PrimitiveType == PrimitiveType.Void &&
expressionType != PrimitiveType.Void)
{
Context.ErrorService.Add(
ErrorType.Unknown,
node.Expression.Token ?? currentNode.Id.Token,
$"cannot return a value from procedure {id}"
);
}
//throw new Exception($"cannot return a value from procedure {id}");
if (node.Expression is NoOpNode && expressionType != PrimitiveType.Void &&
currentNode.Type.PrimitiveType != PrimitiveType.Void)
{
Context.ErrorService.Add(
ErrorType.Unknown,
node.Expression.Token,
$"must return value of {type} from function {id}"
);
}
// throw new Exception($"must return value of {type} from function {id}");
if (type is ArrayTypeNode at)
{
if (expressionType != PrimitiveType.Array)
{
Context.ErrorService.Add(
ErrorType.Unknown,
node.Expression.Token,
$"must return array of type {at.SubType} from function{id}, tried to return {expressionType}"
);
//throw new Exception(
// $"must return array of type {at.SubType} from function{id}, tried to return {expressionType}");
}
if (at.SubType != expressionSubType)
{
Context.ErrorService.Add(
ErrorType.Unknown,
node.Expression.Token,
$"must return array of type {at.SubType} from function{id}, tried to return array of {expressionSubType}"
);
//throw new Exception(
// $"must return array of type {at.SubType} from function{id}, tried to return array of {expressionSubType}");
}
}
else
{
if (expressionType != type.PrimitiveType && currentNode.Type.PrimitiveType != PrimitiveType.Void)
{
Context.ErrorService.Add(
ErrorType.Unknown,
node.Expression.Token ?? currentNode.Id.Token,
$"must return value of type {type.PrimitiveType} from function {id}, tried to return {expressionType}"
);
}
//throw new Exception(
// $"must return value of type {type.PrimitiveType} from function{id}, tried to return {expressionType}");
}
return(null);
}
static bool CheckReturnStatement(ReturnStatementNode node, List <string> validVariables,
List <string> validMethods,
List <string> variableTypes, ClassDeclarationNode currentClass, string targetReturnType)
{
return(CheckExpression(node.expression, validVariables, validMethods, variableTypes, currentClass, targetReturnType));
}
public override void Visit(ReturnStatementNode node)
{
node.expression.Accept(this);
}
/// <summary>
/// Visits the Return Statement node.
/// </summary>
/// <param name="node">The node to visit.</param>
public virtual TResult VisitReturnStatement(ReturnStatementNode node)
{
throw new NotImplementedException();
}
public virtual Value evaluate(Context cx, ReturnStatementNode node)
{
output("<ReturnStatementNode position=\"" + node.pos() + "\">");
indent_Renamed_Field++;
if (node.expr != null)
{
node.expr.evaluate(cx, this);
}
indent_Renamed_Field--;
output("</ReturnStatementNode>");
return null;
}
