private IList <StatementNode> getForInit(ForInitContext forInit)
{
if (forInit == null)
{
return(CollectionUtils.emptyList <StatementNode>());
}
ExpressionListContext statementExpressionList = forInit.expressionList();
if (statementExpressionList != null)
{
IList <ExpressionContext> statementExpressionContexts = statementExpressionList._statements;
StatementNode[] statements = new StatementNode[statementExpressionContexts.Count];
for (var i = 0; i < statementExpressionContexts.Count; i++)
{
Expression expr = (Expression)VisitExpression(statementExpressionContexts[i]);
statements[i] = new ExpressionStatement(expr.beginLine, expr.beginCol,
expr.endLine, expr.endCol, expr);
}
return(statements);
}
VariableDeclarationContext variableDeclaration = forInit.variableDeclaration();
if (variableDeclaration != null)
{
return(CollectionUtils.singletonList((StatementNode)VisitVariableDeclaration(variableDeclaration)));
}
return(null);
}
public override object VisitVariableDeclaration([NotNull] VariableDeclarationContext context)
{
//check whether expression after WithValue matches type
var varName = context.VARNAME()?.GetText();
var varType = TypeSystem.Instance["ErrorType"];
try
{
varType = TypeSystem.Instance[context.typeName?.Text];
}
catch (KeyNotFoundException e)
{
errors.Add(new Error(context.typeName, e.Message));
}
AddSymbolToScope(context, new Symbol(varName, varType));
if (context.expression() != null)
{
var expressionType = TypeVisitor.GetType(context.expression(), scope, errors);
var symbol = GetSymbolFromScope(context, varName);
if (symbol != null)
{
if (!expressionType.InheritsFrom(varType))
{
errors.Add(new Error(context.expression(), $"Type mismatch: expression of type {expressionType} cannot be assigned to a variable of type {varType}"));
}
}
}
return(base.VisitVariableDeclaration(context));
}
public override Symbol VisitVariableDeclaration([NotNull] VariableDeclarationContext context)
{
var variableType = context.variableType().Accept(this).ReturnType;
var identifier = context.IDENTIFIER().GetText();
callStack.Current.AddVariable(identifier, variableType, context?.data()?.Accept(this).AsString);
return(null);
}
public override void ExitVariableDeclaration([NotNull] VariableDeclarationContext context)
{
base.ExitVariableDeclaration(context);
startVar = false;
isarray = false;
if (currStruct != null)
{
parseVariables(context);
}
}
public override void ExitVariableDeclaration(VariableDeclarationContext context)
{
string variablesType = AsType(context.GetChild <TypeIdentifierContext>(0));
IList <IParseTree> variables = context.GetChild <IdentifierListContext>(0).children;
for (int i = 0; i < variables.Count; i += 2)
{
AppendLine(variablesType, " ", variables[i].GetText().ToLower(), " = default(", variablesType, ");");
}
}
public override Tree VisitVariableDeclaration(VariableDeclarationContext context)
{
String name = context.name.Text;
TypeTree type = (TypeTree)VisitType(context.type());
ExpressionContext initContext = context.init;
Expression init = null;
if (initContext != null)
{
init = (Expression)VisitExpression(initContext);
}
return(new VariableDeclaration(type.beginLine, type.beginCol, context.Stop.Line,
context.Stop.Column, name, type, init));
}
private void ParseNode(IParseTree node)
{
if (node is SourceElementsContext)
{
SourceElementsContext elementsContext = node as SourceElementsContext;
SourceElementContext[] srcElements = elementsContext.sourceElement();
foreach (SourceElementContext srcElement in srcElements)
{
StatementContext statementContext = srcElement.statement();
VariableStatementContext varStatementContext = statementContext.variableStatement();
FunctionDeclarationContext functionContext = statementContext.functionDeclaration();
ImportStatementContext importContext = statementContext.importStatement();
ExportStatementContext exportContext = statementContext.exportStatement();
if (varStatementContext != null)
{
VariableDeclarationListContext variableListContex = varStatementContext.variableDeclarationList();
if (variableListContex != null)
{
var variables = variableListContex.children;
foreach (var variable in variables)
{
if (variable is VariableDeclarationContext)
{
VariableDeclarationContext declarationContext = variable as VariableDeclarationContext;
string name = declarationContext.assignable().GetText();
ObjectLiteralExpressionContext[] exps = declarationContext.GetRuleContexts <ObjectLiteralExpressionContext>();
if (exps == null || exps.Length == 0)
{
this.WriteKeyValue("Field", name);
}
else
{
this.WriteKeyValue("Class", name);
this.WriteBeginBrace();
foreach (ObjectLiteralExpressionContext exp in exps)
{
ObjectLiteralContext literalContext = exp.objectLiteral();
PropertyAssignmentContext[] properties = literalContext.propertyAssignment();
foreach (PropertyAssignmentContext property in properties)
{
PropertyNameContext propertyNameContext = property.GetRuleContext <PropertyNameContext>(0);
FunctionExpressionContext funcExpContext = property.GetRuleContext <FunctionExpressionContext>(0);
bool isFunction = funcExpContext != null;
string propertyName = propertyNameContext.identifierName().GetText();
this.WriteKeyValue(isFunction ? "Function" : "Property", propertyName);
}
}
this.WriteEndBrace();
}
}
}
}
}
else if (functionContext != null)
{
string name = functionContext.Identifier().GetText();
this.WriteKeyValue("Function", name);
}
else if (importContext != null)
{
ImportFromBlockContext fromContext = importContext.importFromBlock();
ModuleItemsContext[] moduleItems = fromContext.GetRuleContexts <ModuleItemsContext>();
foreach (ModuleItemsContext module in moduleItems)
{
AliasNameContext[] aliasNames = module.aliasName();
foreach (AliasNameContext aliasName in aliasNames)
{
string name = aliasName.identifierName().LastOrDefault().GetText();
this.WriteKeyValue("Import", name);
}
}
}
else if (exportContext != null)
{
DeclarationContext[] declarations = exportContext.GetRuleContexts <DeclarationContext>();
ExportFromBlockContext[] exportBlocks = exportContext.GetRuleContexts <ExportFromBlockContext>();
foreach (DeclarationContext declaration in declarations)
{
FunctionDeclarationContext funcContext = declaration.functionDeclaration();
if (funcContext != null)
{
string name = funcContext.Identifier().GetText();
this.WriteKeyValue("Export", name);
}
}
foreach (ExportFromBlockContext exportBlock in exportBlocks)
{
ModuleItemsContext[] moduleItems = exportBlock.GetRuleContexts <ModuleItemsContext>();
foreach (ModuleItemsContext module in moduleItems)
{
AliasNameContext[] aliasNames = module.aliasName();
foreach (AliasNameContext aliasName in aliasNames)
{
IdentifierNameContext[] identifierNames = aliasName.identifierName();
string name = identifierNames.LastOrDefault().Identifier().GetText();
this.WriteKeyValue("Export", name);
}
}
}
}
}
}
}
public override void EnterVariableDeclaration([NotNull] VariableDeclarationContext context)
{
base.EnterVariableDeclaration(context);
startVar = true;
}
