public override ICatchClause Rewrite(ICatchClause catchClause) { _log.Info("Rewriting ITryCatchFinallyStatement: " + catchClause + " Pass: "******".ctor")); expression = new CreateObjectInstance() { MethodToCall = ctor, Type = catchClause.ExceptionContainer.Type }; } return(new CatchClause(catchClause) { Body = new BlockStatement() { Statements = new ThrowStatement() { Exception = expression }.InList <IStatement>() } }); }
private void AddEntryPointMethod(Compilation compilation) { List<Expression> args = new List<Expression>(1); args.Add(new CompileTimeConstant(0, SourceDummy.SourceLocation)); Expression createInstance = new CreateObjectInstance(new NamedTypeExpression(new SimpleName(this.Name, SourceDummy.SourceLocation, false)), args, SourceDummy.SourceLocation); Expression callMain = new MethodCall( new QualifiedName(createInstance, new SimpleName(compilation.NameTable.GetNameFor("Main"), SourceDummy.SourceLocation, false), SourceDummy.SourceLocation), Expression.EmptyCollection, SourceDummy.SourceLocation); List<Statement> body = new List<Statement>(1); body.Add(new ExpressionStatement(callMain)); MethodDeclaration entryPointMethod = new MethodDeclaration(null, MethodDeclaration.Flags.Static, TypeMemberVisibility.Public, TypeExpression.For(compilation.PlatformType.SystemVoid.ResolvedType), null, new NameDeclaration(compilation.NameTable.GetNameFor("EntryPoint"), SourceDummy.SourceLocation), null, null, null, new BlockStatement(body, this.SourceLocation), this.SourceLocation); this.members.Add(entryPointMethod); }
public override IExpression VisitObjectCreationExpression(ObjectCreationExpressionSyntax node) { var o = this.semanticModel.GetSymbolInfo(node); var s = o.Symbol; if (s != null) { MethodSymbol ms = s as MethodSymbol; var mr = this.mapper.Map(ms); var e = new CreateObjectInstance() { Locations = Helper.SourceLocation(this.tree, node), MethodToCall = mr, Type = mr.ContainingType, }; return(e); } throw new InvalidDataException("VisitObjectCreationExpression couldn't find something to return"); }
public override void TraverseChildren(IBlockStatement blockStatement) { base.TraverseChildren(blockStatement); Contract.Assume(blockStatement is BlockStatement); var block = this.currentBlock = (BlockStatement)blockStatement; var n = block.Statements.Count; int i; for (i = 0; i < n; i++) { var statement = block.Statements[i]; Contract.Assume(statement != null); if (statement is EmptyStatement) { continue; } var decl = statement as LocalDeclarationStatement; if (decl == null) { break; } this.declarationFor.Add(decl.LocalVariable, decl); } int unifications = 0; for (; i < n; i++) { var statement = block.Statements[i]; Contract.Assume(statement != null); var es = statement as ExpressionStatement; if (es == null) { if (statement is EmptyStatement || statement is LabeledStatement) { continue; } break; } ILocalDefinition local = null; var assignment = es.Expression as Assignment; IExpression initialValue = null; if (assignment != null) { initialValue = assignment.Source; local = assignment.Target.Definition as ILocalDefinition; if (local == null) { var addressDeref = assignment.Target.Definition as IAddressDereference; if (addressDeref == null) { continue; } var addressOf = addressDeref.Address as IAddressOf; if (addressOf == null) { continue; } var addressableExpression = addressOf.Expression as IAddressableExpression; if (addressableExpression == null) { continue; } local = addressableExpression.Definition as ILocalDefinition; if (local == null || this.firstReferenceToLocal[local] != addressableExpression) { continue; } } else { if (this.firstReferenceToLocal[local] != assignment.Target) { continue; } } } else { var mcall = es.Expression as MethodCall; if (mcall == null || mcall.IsStaticCall || mcall.IsJumpCall || mcall.MethodToCall.Type.TypeCode != PrimitiveTypeCode.Void || mcall.MethodToCall.Name.Value != ".ctor") { continue; } var addressOf = mcall.ThisArgument as IAddressOf; if (addressOf == null) { continue; } var addressableExpression = addressOf.Expression as IAddressableExpression; if (addressableExpression == null) { continue; } local = addressableExpression.Definition as ILocalDefinition; if (local == null || this.firstReferenceToLocal[local] != addressableExpression) { continue; } if (this.declarationFor.ContainsKey(local)) { initialValue = new CreateObjectInstance() { Arguments = mcall.Arguments, Locations = mcall.Locations, MethodToCall = mcall.MethodToCall, Type = mcall.MethodToCall.ContainingType } } ; } if (local == null || initialValue == null) { continue; } LocalDeclarationStatement decl; if (!this.declarationFor.TryGetValue(local, out decl)) { continue; } Contract.Assume(decl != null); this.unifiedDeclarations.Add(decl); this.declarationFor.Remove(local); decl.InitialValue = initialValue; block.Statements[i] = decl; unifications++; } if (unifications == 0) { return; } var newStatements = new List <IStatement>(block.Statements.Count - unifications); for (i = 0; i < n; i++) { var statement = block.Statements[i]; var decl = statement as LocalDeclarationStatement; if (decl != null) { if (this.unifiedDeclarations.Contains(decl)) { this.unifiedDeclarations.Remove(decl); continue; } if (this.numberOfReferencesToLocal[decl.LocalVariable] == 0 && this.numberOfAssignmentsToLocal[decl.LocalVariable] == 0) { continue; } } newStatements.Add(statement); } block.Statements = newStatements; }
private Expression ParseNew(TokenSet followers) //^ requires this.currentToken == Token.New; //^ ensures followers[this.currentToken] || this.currentToken == Token.EndOfFile; { SourceLocationBuilder ctx = new SourceLocationBuilder(this.scanner.SourceLocationOfLastScannedToken); this.GetNextToken(); if (this.currentToken == Token.LeftBracket) return this.ParseNewImplicitlyTypedArray(ctx, followers); if (this.currentToken == Token.LeftBrace) return this.ParseNewAnonymousTypeInstance(ctx, followers); TypeExpression t = this.ParseBaseTypeExpression(false, followers|Parser.InfixOperators|Token.LeftBracket|Token.LeftParenthesis|Token.RightParenthesis); if (this.currentToken == Token.Conditional) { SourceLocationBuilder slb = new SourceLocationBuilder(t.SourceLocation); slb.UpdateToSpan(this.scanner.SourceLocationOfLastScannedToken); //^ assume this.currentToken == Token.Conditional; //no side effects from the methods can touch this.currentToken this.GetNextToken(); t = new NullableTypeExpression(t, slb); //} else if (this.currentToken == Token.LogicalNot) { // TypeExpression type = t; // t = new NonNullableTypeExpression(type); // t.SourceContext = type.SourceContext; // t.SourceContext.EndPos = this.scanner.endPos; // this.GetNextToken(); } else if (this.currentToken == Token.Multiply) { SourceLocationBuilder slb = new SourceLocationBuilder(t.SourceLocation); slb.UpdateToSpan(this.scanner.SourceLocationOfLastScannedToken); //^ assume this.currentToken == Token.Multiply; //no side effects from the methods can touch this.currentToken this.GetNextToken(); t = new PointerTypeExpression(t, slb); } ctx.UpdateToSpan(t.SourceLocation); TypeExpression et = t; uint rank = 0; while (this.currentToken == Token.LeftBracket) { Token nextTok = this.PeekNextToken(); if (nextTok != Token.Comma && nextTok != Token.RightBracket) break; //not a rank specifier, but a size specifier rank = this.ParseRankSpecifier(ctx, followers|Token.LeftBrace|Token.LeftBracket|Token.LeftParenthesis|Token.RightParenthesis); et = t; t = new ArrayTypeExpression(et, rank, ctx); } if (rank > 0) { //new T[] {...} or new T[,] {{..} {...}...}, etc where T can also be an array type List<Expression> initializers; if (this.currentToken == Token.LeftBrace) initializers = this.ParseArrayInitializers(rank, et, followers, false, ctx); else { initializers = new List<Expression>(0); if (Parser.UnaryStart[this.currentToken]) this.HandleError(Error.ExpectedLeftBrace); else this.HandleError(Error.MissingArraySize); while (Parser.UnaryStart[this.currentToken]) { this.ParseExpression(followers|Token.Comma|Token.RightBrace); if (this.currentToken != Token.Comma) break; this.GetNextToken(); } ctx.UpdateToSpan(this.scanner.SourceLocationOfLastScannedToken); this.SkipOverTo(Token.RightBrace, followers); } return new CreateArray(et, initializers.AsReadOnly(), new List<Expression>(0).AsReadOnly(), rank, new List<Expression>(0).AsReadOnly(), ctx); } if (this.currentToken == Token.LeftBracket) { //new T[x] or new T[x,y] etc. possibly followed by an initializer or element type rank specifier this.GetNextToken(); List<Expression> sizes = this.ParseExpressionList(ctx, followers|Token.LeftBrace|Token.LeftBracket); rank = (uint)sizes.Count; List<Expression> initializers; if (this.currentToken == Token.LeftBrace) initializers = this.ParseArrayInitializers(rank, t, followers, false, ctx); else { uint elementRank = 0; tryAgain: while (this.currentToken == Token.LeftBracket) { Token nextTok = this.PeekNextToken(); if (nextTok != Token.Comma && nextTok != Token.RightBracket) break; //not a rank specifier, but a size specifier elementRank = this.ParseRankSpecifier(ctx, followers|Token.LeftBrace|Token.LeftBracket|Token.LeftParenthesis|Token.RightParenthesis); t = new ArrayTypeExpression(t, elementRank, ctx); } if (this.currentToken == Token.LeftBrace) initializers = this.ParseArrayInitializers(rank, t, followers, false, ctx); else { if (this.currentToken == Token.LeftBracket) { //new T[x][y] or something like that this.GetNextToken(); this.HandleError(Error.InvalidArray); elementRank = (uint)this.ParseExpressionList(ctx, followers).Count; goto tryAgain; } else { initializers = new List<Expression>(0); ctx.UpdateToSpan(this.scanner.SourceLocationOfLastScannedToken); this.SkipTo(followers); } } } return new CreateArray(t, initializers.AsReadOnly(), new List<Expression>(0).AsReadOnly(), rank, sizes.AsReadOnly(), ctx); } //new T(...) IEnumerable<Expression> arguments = Expression.EmptyCollection; IEnumerable<Expression> elementValues = Expression.EmptyCollection; IEnumerable<NamedArgument> namedArguments = NamedArgument.EmptyCollection; if (this.currentToken == Token.LeftParenthesis) { //if (t is NonNullableTypeExpression) { // this.SkipTo(followers, Error.BadNewExpr); // return null; //} arguments = this.ParseArgumentList(ctx, followers|Token.LeftBrace).AsReadOnly(); } else if (this.currentToken != Token.LeftBrace) { this.SkipTo(followers, Error.BadNewExpr); } Expression result = new CreateObjectInstance(t, arguments, ctx.GetSourceLocation()); if (this.currentToken == Token.LeftBrace) { this.ParseElementValuesOrNamedArguments(ref elementValues, ref namedArguments, ctx, followers); if (elementValues != Expression.EmptyCollection) return new PopulateCollection(result, elementValues, ctx); else if (namedArguments != NamedArgument.EmptyCollection) return new InitializeObject(result, namedArguments, ctx); else { this.HandleError(Error.SyntaxError); //TODO: better error } } return result; }