override public object Clone() { DeclarationStatement clone = (DeclarationStatement)FormatterServices.GetUninitializedObject(typeof(DeclarationStatement)); clone._lexicalInfo = _lexicalInfo; clone._endSourceLocation = _endSourceLocation; clone._documentation = _documentation; clone._entity = _entity; if (_annotations != null) { clone._annotations = (Hashtable)_annotations.Clone(); } if (null != _modifier) { clone._modifier = _modifier.Clone() as StatementModifier; clone._modifier.InitializeParent(clone); } if (null != _declaration) { clone._declaration = _declaration.Clone() as Declaration; clone._declaration.InitializeParent(clone); } if (null != _initializer) { clone._initializer = _initializer.Clone() as Expression; clone._initializer.InitializeParent(clone); } return(clone); }
protected override Statement ExpandImpl(MacroStatement macro){ var result = new Block(); foreach (Statement st in macro.Body.Statements){ var decl = st as DeclarationStatement; var refer = st as ExpressionStatement; if(null==decl){ var ex = refer.Expression; if (ex is MethodInvocationExpression){ decl = new DeclarationStatement( new Declaration(((MethodInvocationExpression) refer.Expression).Target.ToCodeString(), null), null); } if(ex is BinaryExpression){ var b = ex as BinaryExpression; decl = new DeclarationStatement( new Declaration(b.Left.ToCodeString(),null),b.Right ); } } var bin = new BinaryExpression(BinaryOperatorType.Assign, new TryCastExpression(new ReferenceExpression(decl.Declaration.Name), decl.Declaration.Type), decl.Initializer); var def = new MacroStatement("definebrailproperty"); def.Arguments.Add(bin); result.Add(def); } return result; }
override public object Clone() { DeclarationStatement clone = new DeclarationStatement(); clone._lexicalInfo = _lexicalInfo; clone._endSourceLocation = _endSourceLocation; clone._documentation = _documentation; clone._isSynthetic = _isSynthetic; clone._entity = _entity; if (_annotations != null) { clone._annotations = (Hashtable)_annotations.Clone(); } if (null != _modifier) { clone._modifier = _modifier.Clone() as StatementModifier; clone._modifier.InitializeParent(clone); } if (null != _declaration) { clone._declaration = _declaration.Clone() as Declaration; clone._declaration.InitializeParent(clone); } if (null != _initializer) { clone._initializer = _initializer.Clone() as Expression; clone._initializer.InitializeParent(clone); } return(clone); }
static void ReplaceWithInitializer(DeclarationStatement decl) { if (decl.Initializer == null) { decl.ReplaceBy(null); } else { ExpressionStatement statement = new ExpressionStatement(decl.LexicalInfo); statement.Expression = new BinaryExpression(decl.LexicalInfo, BinaryOperatorType.Assign, new ReferenceExpression(decl.Declaration.LexicalInfo, decl.Declaration.Name), decl.Initializer); decl.ReplaceBy(statement); } }
public static TypeMember Lift(DeclarationStatement stmt) { var closure = stmt.Initializer as BlockExpression; if (closure != null && closure.ContainsAnnotation(BlockExpression.ClosureNameAnnotation)) return TypeMember.Lift(closure); return new Field(stmt.LexicalInfo) { Name = stmt.Declaration.Name, Type = stmt.Declaration.Type, Initializer = stmt.Initializer }; }
public object VisitLocalVariableDeclaration(LocalVariableDeclaration lvd, object data) { ArrayList list = new ArrayList(); for (int i = 0; i < lvd.Variables.Count; i++) { B.DeclarationStatement varDecl = new B.DeclarationStatement(GetLexicalInfo(lvd)); varDecl.Declaration = new B.Declaration(GetLexicalInfo(lvd.Variables[i]), lvd.Variables[i].Name, ConvertTypeReference(lvd.GetTypeForVariable(i))); varDecl.Initializer = ConvertExpression(lvd.Variables[i].Initializer); list.Add(varDecl); } return(list); }
public override void LeaveDeclarationStatement(DeclarationStatement node) { if (node.Declaration.Type != null) { Expression initializer = node.Initializer; if (initializer is TryCastExpression) { TryCastExpression tryCastExpression = (TryCastExpression)initializer; Expression target = tryCastExpression.Target; TypeReference type = tryCastExpression.Type; node.Initializer = target; } } }
public static Statement read (Expression expression){ Declaration declaraion = new Declaration(); declaraion.Name = "readedContent"; Expression arg = null; if (expression is BinaryExpression){ var ass = expression as BinaryExpression; declaraion.Name=ass.Left.LiftToString(); arg = ass.Right; }else{ arg = expression; } MethodInvocationExpression assign = AstUtil.CreateMethodInvocationExpression(AstUtil.CreateReferenceExpression("System.IO.File.ReadAllText"), arg); var result = new DeclarationStatement(declaraion, assign); return result; }
public static TypeMember Lift(DeclarationStatement stmt) { var closure = stmt.Initializer as BlockExpression; if (closure != null && closure.ContainsAnnotation(BlockExpression.ClosureNameAnnotation)) { return(TypeMember.Lift(closure)); } return(new Field(stmt.LexicalInfo) { Name = stmt.Declaration.Name, Type = stmt.Declaration.Type, Initializer = stmt.Initializer }); }
public static void RenameLocals(Block block, StringComparer nameComparer) { FindVariableDeclarationsVisitor fvdv = new FindVariableDeclarationsVisitor(); block.Accept(fvdv); List<DeclarationStatement> list = new List<DeclarationStatement>(); foreach (DeclarationStatement decl in fvdv.Declarations) { DeclarationStatement conflict = null; int conflictIndex = -1; for (int i = 0; i < list.Count; i++) { if (nameComparer.Equals(list[i].Declaration.Name, decl.Declaration.Name)) { conflict = list[i]; conflictIndex = i; break; } } if (conflict == null) { list.Add(decl); } else { // Handle conflict: try if "moveup" would be sufficient if (IsSameType(decl.Declaration.Type, conflict.Declaration.Type, nameComparer)) { // create declaration at beginning of class and // replace decl & conflict by assignment DeclarationStatement newDecl = new DeclarationStatement(conflict.LexicalInfo); newDecl.Declaration = new Declaration(conflict.Declaration.LexicalInfo, conflict.Declaration.Name, conflict.Declaration.Type); block.Insert(0, newDecl); ReplaceWithInitializer(decl); ReplaceWithInitializer(conflict); list[conflictIndex] = newDecl; } else { string newName = FindFreeName(decl.Declaration.Name, list, fvdv.Declarations, nameComparer); decl.ParentNode.Accept(new RenameLocalsVisitor(decl.Declaration.Name, newName, nameComparer)); decl.Declaration.Name = newName; } } } }
public void declaration_statement(Block b) { try { Expression expression; Declaration declaration = this.declaration(); switch (this.LA(1)) { case 0x4e: this.match(0x4e); expression = this.expression(); break; case 1: case 5: case 7: case 8: case 9: case 10: case 11: case 12: case 13: case 15: case 0x10: case 0x11: case 0x12: case 0x13: case 20: case 0x15: case 0x19: case 0x1b: case 0x1d: case 30: case 0x1f: case 0x20: case 0x21: case 0x23: case 0x24: case 0x25: case 0x26: case 0x27: case 40: case 0x29: case 0x2a: case 0x2b: case 0x2c: case 0x2d: case 0x2e: case 0x2f: case 0x30: case 0x31: case 50: case 0x33: case 0x3b: case 60: case 0x3d: case 0x3e: case 0x3f: case 0x44: case 0x4d: case 0x4f: case 80: case 0x52: case 0x58: case 0x63: case 0x67: case 0x69: case 0x6a: case 0x6b: case 0x6c: case 0x6d: break; default: throw new NoViableAltException(this.LT(1), this.getFilename()); } if (base.inputState.guessing == 0) { DeclarationStatement statement; DeclarationStatement statement1 = statement = new DeclarationStatement(declaration.get_LexicalInfo()); statement.set_Declaration(declaration); statement.set_Initializer(expression); DeclarationStatement statement2 = statement; b.Add(statement2); } } catch (RecognitionException exception) { if (base.inputState.guessing != 0) { throw; } this.reportError(exception); this.recover(exception, tokenSet_15_); } }
public Expression Linqify(BlockExpression nodeToConvert, BlockExpression originalNode) { //assert on param //assert one expression statement if (nodeToConvert.Parameters.Count > 1) { throw new NotSupportedException("Only lambdas with zero or one parameter are supported"); } if (nodeToConvert.Body.Statements.Count != 1 && nodeToConvert.Body.FirstStatement as ExpressionStatement == null) { throw new NotSupportedException("A lambda expression with a statement body cannot be converted to an expression tree"); } var closureReturnType = CodeBuilder.CreateTypeReference((originalNode.ExpressionType as ICallableType).GetSignature().ReturnType); var bodyReturnType = CodeBuilder.CreateTypeReference((originalNode.Body.FirstStatement as ReturnStatement).Expression.ExpressionType); var hasParameters = nodeToConvert.Parameters.Count == 1; if (hasParameters) { var closureParameter = originalNode.Parameters[0]; var exprP1Init = new DeclarationStatement(new Declaration(nodeToConvert.LexicalInfo, CompilerContext.Current.GetUniqueName(closureParameter.Name)), new MethodInvocationExpression(ReferenceExpression.Lift("System.Linq.Expressions.Expression.Parameter"), new TypeofExpression() { Type = closureParameter.Type }, new StringLiteralExpression(closureParameter.Name))); var exprP1Ref = new ReferenceExpression(exprP1Init.Declaration.Name); var visitor = new GeneratorExpressionTrees(closureParameter.Name, exprP1Ref, NameResolutionService, CodeBuilder); visitor.Visit(nodeToConvert.Body); var constructedExpression = visitor.Expression; constructedExpression = AddOptionalConvert(closureReturnType, bodyReturnType, constructedExpression); var exprLambdaGenericArg = new GenericTypeReference("System.Func", closureParameter.Type, closureReturnType); var exprLambdaCall = new GenericReferenceExpression() { Target = ReferenceExpression.Lift("System.Linq.Expressions.Expression.Lambda"), GenericArguments = { exprLambdaGenericArg } }; var resultExpr = new MethodInvocationExpression(exprLambdaCall, constructedExpression, exprP1Ref); var linqify = new BlockExpression(); var returnType = new GenericTypeReference("System.Linq.Expressions.Expression", exprLambdaGenericArg); NameResolutionService.ResolveSimpleTypeReference(returnType); //this must be set to allow proper type inference originalNode.ExpressionType = returnType.Entity as IType; linqify.ReturnType = returnType; linqify.Body.Add(exprP1Init); linqify.Body.Add(new ReturnStatement(resultExpr)); return new MethodInvocationExpression(linqify); } else { var visitor = new GeneratorExpressionTrees(null, null, NameResolutionService, CodeBuilder); visitor.Visit(nodeToConvert.Body); var constructedExpression = visitor.Expression; constructedExpression = AddOptionalConvert(closureReturnType, bodyReturnType, constructedExpression); var exprLambdaGenericArg = new GenericTypeReference("System.Func", closureReturnType); var exprLambdaCall = new GenericReferenceExpression() { Target = ReferenceExpression.Lift("System.Linq.Expressions.Expression.Lambda"), GenericArguments = { exprLambdaGenericArg } }; var resultExpr = new MethodInvocationExpression(exprLambdaCall, constructedExpression); var linqify = new BlockExpression(); var returnType = new GenericTypeReference("System.Linq.Expressions.Expression", exprLambdaGenericArg); NameResolutionService.ResolveSimpleTypeReference(returnType); //this must be set to allow proper type inference originalNode.ExpressionType = returnType.Entity as IType; linqify.ReturnType = returnType; linqify.Body.Add(new ReturnStatement(resultExpr)); return new MethodInvocationExpression(linqify); } }
public override void OnDeclarationStatement(DeclarationStatement node) { if (node.Declaration.Type != null && !SearchField(node.Declaration.Name)) { TypeReference initializerType = GetInferredType(node.Initializer); if (node.Declaration.Type.Matches(initializerType)) { node.Declaration.Type = null; } } base.OnDeclarationStatement(node); }
private IType GetDeclarationType(DeclarationStatement node) { return GetType(node.Declaration.Type); }
public override void LeaveDeclarationStatement(DeclarationStatement node) { EnsureDeclarationType(node); AssertDeclarationName(node.Declaration); var type = GetDeclarationType(node); var localInfo = DeclareLocal(node, node.Declaration.Name, type); var loopLocal = localInfo as InternalLocal; if (null != loopLocal) loopLocal.OriginalDeclaration = node.Declaration; if (node.Initializer != null) { IType initializerType = GetExpressionType(node.Initializer); if (CheckDeclarationType(node.Declaration.Type)) AssertTypeCompatibility(node.Initializer, type, initializerType); if (TypeSystemServices.IsNullable(type) && !TypeSystemServices.IsNullable(initializerType)) BindNullableInitializer(node, node.Initializer, type); node.ReplaceBy( new ExpressionStatement( CodeBuilder.CreateAssignment( node.LexicalInfo, CodeBuilder.CreateReference(localInfo), node.Initializer))); } else node.ReplaceBy(new ExpressionStatement(CreateDefaultLocalInitializer(node, localInfo))); }
protected DeclarationStatement declaration_stmt() //throws RecognitionException, TokenStreamException { DeclarationStatement s; IToken id = null; s = null; TypeReference tr = null; Expression initializer = null; StatementModifier m = null; try { // for error handling id = LT(1); match(ID); match(AS); tr=type_reference(); { switch ( LA(1) ) { case ASSIGN: { { match(ASSIGN); { if (((tokenSet_95_.member(LA(1))) && (tokenSet_96_.member(LA(2))))&&(_compact)) { initializer=simple_initializer(); } else if ((tokenSet_95_.member(LA(1))) && (tokenSet_97_.member(LA(2)))) { initializer=declaration_initializer(); } else { throw new NoViableAltException(LT(1), getFilename()); } } } break; } case EOL: case IF: case UNLESS: case WHILE: case EOS: { { if (!(!_compact)) throw new SemanticException("!_compact"); { switch ( LA(1) ) { case IF: case UNLESS: case WHILE: { m=stmt_modifier(); break; } case EOL: case EOS: { break; } default: { throw new NoViableAltException(LT(1), getFilename()); } } } eos(); } break; } default: { throw new NoViableAltException(LT(1), getFilename()); } } } if (0==inputState.guessing) { Declaration d = new Declaration(ToLexicalInfo(id)); d.Name = id.getText(); d.Type = tr; s = new DeclarationStatement(d.LexicalInfo); s.Declaration = d; s.Initializer = initializer; s.Modifier = m; } } catch (RecognitionException ex) { if (0 == inputState.guessing) { reportError(ex, "declaration_stmt"); recover(ex,tokenSet_22_); } else { throw ex; } } return s; }
public object VisitLocalVariableDeclaration(LocalVariableDeclaration lvd, object data) { ArrayList list = new ArrayList(); for (int i = 0; i < lvd.Variables.Count; i++) { B.DeclarationStatement varDecl = new B.DeclarationStatement(GetLexicalInfo(lvd)); varDecl.Declaration = new B.Declaration(GetLexicalInfo(lvd.Variables[i]), lvd.Variables[i].Name, ConvertTypeReference(lvd.GetTypeForVariable(i))); varDecl.Initializer = ConvertExpression(lvd.Variables[i].Initializer); list.Add(varDecl); } return list; }
public override void OnDeclarationStatement(DeclarationStatement node) { CodeVariableDeclarationStatement var = new CodeVariableDeclarationStatement(ConvTypeRef(node.Declaration.Type), node.Declaration.Name); if (node.Initializer != null) { _expression = null; node.Initializer.Accept(this); var.InitExpression = _expression; } _statements.Add(var); }
public override void OnDeclarationStatement(DeclarationStatement d) { WriteIndented(); Visit(d.Declaration); if (null != d.Initializer) { WriteOperator(" = "); Visit(d.Initializer); } WriteLine(); }
public override void OnDeclarationStatement(DeclarationStatement node) { declarations.Add(node); base.OnDeclarationStatement(node); }
//throws RecognitionException, TokenStreamException protected DeclarationStatement declaration_stmt() { DeclarationStatement s; IToken id = null; s = null; TypeReference tr = null; Expression initializer = null; StatementModifier m = null; try { // for error handling id = LT(1); match(ID); match(AS); tr=type_reference(); { switch ( LA(1) ) { case ASSIGN: { { match(ASSIGN); initializer=declaration_initializer(); } break; } case EOF: case IF: case UNLESS: case WHILE: case EOS: case NEWLINE: { { { switch ( LA(1) ) { case IF: case UNLESS: case WHILE: { m=stmt_modifier(); break; } case EOF: case EOS: case NEWLINE: { break; } default: { throw new NoViableAltException(LT(1), getFilename()); } } } eos(); } break; } default: { throw new NoViableAltException(LT(1), getFilename()); } } } if (0==inputState.guessing) { Declaration d = new Declaration(SourceLocationFactory.ToLexicalInfo(id)); d.Name = id.getText(); d.Type = tr; s = new DeclarationStatement(d.LexicalInfo); s.Declaration = d; s.Initializer = initializer; s.Modifier = m; } } catch (RecognitionException ex) { if (0 == inputState.guessing) { reportError(ex); recover(ex,tokenSet_79_); } else { throw ex; } } return s; }
private IType GetDeclarationType(DeclarationStatement node) { if (null != node.Declaration.Type) return GetType(node.Declaration.Type); return InferDeclarationType(node); }
protected Statement nested_function() //throws RecognitionException, TokenStreamException { Statement stmt; IToken def = null; IToken id = null; stmt = null; BlockExpression be = null; Block body = null; TypeReference rt = null; try { // for error handling def = LT(1); match(DEF); id = LT(1); match(ID); if (0==inputState.guessing) { be = new BlockExpression(ToLexicalInfo(id)); body = be.Body; } { switch ( LA(1) ) { case LPAREN: { match(LPAREN); parameter_declaration_list(be.Parameters); match(RPAREN); { switch ( LA(1) ) { case AS: { match(AS); rt=type_reference(); if (0==inputState.guessing) { be.ReturnType = rt; } break; } case COLON: { break; } default: { throw new NoViableAltException(LT(1), getFilename()); } } } break; } case COLON: { break; } default: { throw new NoViableAltException(LT(1), getFilename()); } } } compound_stmt(body); if (0==inputState.guessing) { string name = id.getText(); stmt = new DeclarationStatement( ToLexicalInfo(def), new Declaration( ToLexicalInfo(id), name), be); be[BlockExpression.ClosureNameAnnotation] = name; } } catch (RecognitionException ex) { if (0 == inputState.guessing) { reportError(ex, "nested_function"); recover(ex,tokenSet_84_); } else { throw ex; } } return stmt; }
public override void LeaveDeclarationStatement(DeclarationStatement node) { IType type = GetDeclarationType(node); AssertDeclarationName(node.Declaration); IEntity localInfo = DeclareLocal(node, node.Declaration.Name, type); if (null != node.Initializer) { IType itype = GetExpressionType(node.Initializer); AssertTypeCompatibility(node.Initializer, type, itype); if (TypeSystemServices.IsNullable(type) && !TypeSystemServices.IsNullable(itype)) { BindNullableInitializer(node, node.Initializer, type); } node.ReplaceBy( new ExpressionStatement( CodeBuilder.CreateAssignment( node.LexicalInfo, CodeBuilder.CreateReference(localInfo), node.Initializer))); } else { node.ReplaceBy( new ExpressionStatement( CreateDefaultLocalInitializer(node, localInfo))); } }
private void EnsureDeclarationType(DeclarationStatement node) { var declaration = node.Declaration; if (declaration.Type != null) return; declaration.Type = CodeBuilder.CreateTypeReference(declaration.LexicalInfo, InferDeclarationType(node)); }
override public object Clone() { DeclarationStatement clone = new DeclarationStatement(); clone._lexicalInfo = _lexicalInfo; clone._endSourceLocation = _endSourceLocation; clone._documentation = _documentation; clone._isSynthetic = _isSynthetic; clone._entity = _entity; if (_annotations != null) clone._annotations = (Hashtable)_annotations.Clone(); if (null != _modifier) { clone._modifier = _modifier.Clone() as StatementModifier; clone._modifier.InitializeParent(clone); } if (null != _declaration) { clone._declaration = _declaration.Clone() as Declaration; clone._declaration.InitializeParent(clone); } if (null != _initializer) { clone._initializer = _initializer.Clone() as Expression; clone._initializer.InitializeParent(clone); } return clone; }
private IType InferDeclarationType(DeclarationStatement node) { if (null == node.Initializer) return TypeSystemServices.ObjectType; // The boo syntax does not require this check because // there's no way to create an untyped declaration statement. // This is here to support languages that do allow untyped variable // declarations (unityscript is such an example). return MapNullToObject(GetConcreteExpressionType(node.Initializer)); }
public override void OnDeclarationStatement(DeclarationStatement node) { DeclarationFound(node.Declaration.Name, node.Declaration.Type, node.Initializer, node.LexicalInfo); }