public override void TraverseChildren(IBlockStatement block) { Contract.Assume(block is BlockStatement); var mutableBlock = (BlockStatement)block; this.Traverse(mutableBlock.Statements); foreach (var pair in this.declaringBlockMap) { if (pair.Value != mutableBlock) { continue; } var boundExpr = this.closureFieldToLocalOrParameterMap[pair.Key] as BoundExpression; if (boundExpr == null) { Contract.Assume(false); continue; } var local = boundExpr.Definition as ILocalDefinition; if (local == null) { Contract.Assume(false); continue; } var localDecl = new LocalDeclarationStatement() { LocalVariable = local }; mutableBlock.Statements.Insert(0, localDecl); } }
protected override IPyStatement[] VisitLocalDeclarationStatement(LocalDeclarationStatement src) { var s = new List <IPyStatement>(); foreach (var i in src.Declaration.Declarators) { // to jest przypadek z c# 'int x;', dla Py można to pominąć if (i.Value == null) { continue; } if (i.Value is UnknownIdentifierValue) { throw new NotImplementedException(); } var l = new PyVariableExpression(i.Name, PyVariableKind.Local); var r = TransValue(i.Value); var tt = new PyAssignExpression(l, r); s.Add(new PyExpressionStatement(tt)); //var r = new PyAssignVariable( PyVariableExpression.AddDollar(i.Name), false ); //// r.Name = "$" + i.Name; //r.Value = TV(i.Value); //s.Add(r); } return(s.ToArray()); }
public LogicalBody(Member member, BlockSyntax block, SemanticModel semanticModel) { this.member = member; this.block = block; // parse statments statements = new List <Statement>(); foreach (var s in block.Statements) { var kind = s.Kind(); Statement statement; switch (kind) { case SyntaxKind.ExpressionStatement: statement = new ExpressionStatement((ExpressionStatementSyntax)s, semanticModel); break; case SyntaxKind.ReturnStatement: statement = new ReturnStatement((ReturnStatementSyntax)s, semanticModel); break; case SyntaxKind.LocalDeclarationStatement: statement = new LocalDeclarationStatement((LocalDeclarationStatementSyntax)s, semanticModel); break; default: throw new NotImplementedException("Unsuported Statement SyntaxKind: " + kind); } statements.Add(statement); } }
public override void TraverseChildren(IBlockStatement block) { BasicBlock basicBlock = (BasicBlock)block; List <ILocalDefinition> /*?*/ localsInCurrentScope = basicBlock.LocalVariables; if (localsInCurrentScope != null) { this.AddDeclarationsWithInitialValues(localsInCurrentScope, basicBlock); List <IStatement> prelude = new List <IStatement>(localsInCurrentScope.Count); foreach (ILocalDefinition localDef in localsInCurrentScope) { if (this.declaredLocals.ContainsKey(localDef)) { continue; } LocalDeclarationStatement localDecl = new LocalDeclarationStatement(); localDecl.LocalVariable = localDef; prelude.Add(localDecl); } if (prelude.Count > 0) { basicBlock.Statements.InsertRange(0, prelude); //TODO: use pdb info to insert them in the same order they appear in the source } } this.Traverse(basicBlock.Statements); }
public void VisitDeclaration(LocalDeclarationStatement node) { for (int i = 0; i < node.DeclarationExpressions.Count; i++) { node.DeclarationExpressions[i].Accept(this); } }
public override IStatement VisitVariableDeclaration(VariableDeclarationSyntax node) { ITypeReference t = null; if (!node.Type.IsVar) { var o = this.semanticModel.GetTypeInfo(node.Type); t = this.mapper.Map(o.Type); } var decls = new List <IStatement>(); foreach (var v in node.Variables) { var s = (Microsoft.CodeAnalysis.CSharp.Symbols.LocalSymbol) this.semanticModel.GetDeclaredSymbol(v); IExpression initialValue = null; if (v.Initializer != null) { var evc = v.Initializer.Value; initialValue = this.expressionVisitor.Visit(evc); } var local = new LocalDefinition() { Name = this.host.NameTable.GetNameFor(s.Name), MethodDefinition = this.method, }; this.expressionVisitor.RegisterLocal(s, local); if (t != null) { local.Type = t; } else if (initialValue != null) { local.Type = initialValue.Type; } var ldc = new LocalDeclarationStatement() { InitialValue = initialValue != null ? initialValue : null, LocalVariable = local, Locations = Helper.SourceLocation(this.tree, node), }; decls.Add(ldc); } if (decls.Count == 1) { return(decls[0]); } else { var bs = new BlockStatement() { Statements = decls, }; return(bs); } }
public override void ExtendDeclaration(IDeclarationModel declaration, CompilationModel model) { // this only applies to methods var methodDecl = declaration as MethodDeclaration; if (methodDecl == null || methodDecl.Container == null) return; if (!methodDecl.Definition.Symbol.IsExtensionMethod) throw new CompilationException("The ScriptMixin attribute can only be applied to extension methods.", declaration); // remove the function from the container methodDecl.Container.RemoveMember(methodDecl); // get the extension target info var extTarget = methodDecl.Parameters[0]; var extType = extTarget.Definition.Type; // rewrite first param as a local declaration to this context var thisDecl = new LocalDeclarationStatement { VariableDeclaration = new VariableDeclaration() }; thisDecl.VariableDeclaration.Variables.Add(new VariableDeclarator { Definition = new LocalDefinition { Name = extTarget.Name, Type = extType }, EqualsValueExpression = new LiteralExpression { Text = "this" } }); // add the declaration to the method body methodDecl.Body.Statements.Insert(0, thisDecl); // create a lambda using the method body. var lambdaExpression = new LambdaExpression(); lambdaExpression.Body = methodDecl.Body; for (int i = 1; i < methodDecl.Parameters.Count; i++) lambdaExpression.Parameters.Add(methodDecl.Parameters[i]); // create a global statement to set the prototype value var target = extType.GetFullName() + ".prototype." + methodDecl.Definition.Name; model.GlobalStatements.Add(new ExpressionStatement { Expression = new BinaryExpression { LeftExpression = new LiteralExpression { Text = target }, RightExpression = lambdaExpression, Operator = "=" } }); }
private static void WriteLocalDeclarationStatement(LocalDeclarationStatement statement, StreamWriter writer) { foreach (var variable in statement.variables) { writer.WritePrefix(string.Format("{0} {1} ", variable.typeFullNameFlat, variable.fullNameFlat)); if (variable.initializeExpression != null) { writer.Write("= "); WriteExperesion(variable.initializeExpression, writer); } writer.WriteLine(';'); } }
bool ParseLocalDeclarationStatement(out LocalDeclarationStatement localDeclarationStatement) { localDeclarationStatement = new LocalDeclarationStatement(); if (tokenReader.Expect(LexKind.Keyword)) { if (tokenReader.Expect(LexKind.Identifier, 1)) { if (DataType.IsDataType(tokenReader.Peek().Value)) { localDeclarationStatement = new LocalDeclarationStatement() { DataType = new DataType(tokenReader.Peek().Value, true), Name = tokenReader.Peek(1).Value }; /* If local is assigned at creation */ if (tokenReader.Expect(LexKind.Equals, 2)) { tokenReader.Skip(3); if (ParseExpression(out Expression local)) { localDeclarationStatement.Value = local; } else { Console.WriteLine("Unable to parse expression @ line " + tokenReader.Peek().Line); } } else { tokenReader.Skip(2); } tokenReader.ExpectFatal(LexKind.Semicolon); return(true); } } } return(false); }
static dynamic handle(LocalDeclarationStatement v) { print("creating local variable"); string typename = ((dynamic)v.Type).GenericIdentifier; //TODO: handle more complex local variable delcaration than this. Like templates or something, or "var t = new T(param1, param2)" executingFunction.Localvars[v.Declarators[0].Identifier.Identifier] = new ObjectInstance(typename, v.Declarators[0].Identifier.Identifier); //is this accounting for "Object o = new Object(..."? If so, this is where the identifier is. if (v.Declarators[0].Initializer != null) { executingFunction.Localvars[v.Declarators[0].Identifier.Identifier].value = handle_dyn(v.Declarators[0].Initializer); } //If the ".Initializer" is null, it has a null value, and is waiting to be written to. //we store the name for the object instance creation call ("new T(...)") - see use of "ObjectCreationExpression". localVarDeclarationName = v.Declarators[0].Identifier.Identifier; return(null); }
internal void Traverse(SourceMethodBody body, BasicBlock rootBlock) { this.Traverse(rootBlock); //Now add declarations for any locals declared only on the body (for example temporary variables introduced by Unstacker). List <IStatement> prelude = new List <IStatement>(); var localsAndTemps = body.localVariablesAndTemporaries; this.AddDeclarationsWithInitialValues(localsAndTemps, rootBlock); foreach (var localDef in localsAndTemps) { if (this.declaredLocals.ContainsKey(localDef)) { continue; } LocalDeclarationStatement localDecl = new LocalDeclarationStatement(); localDecl.LocalVariable = localDef; prelude.Add(localDecl); } if (prelude.Count > 0) { rootBlock.Statements.InsertRange(0, prelude); //TODO: use pdb info to insert them in the same order they appear in the source } }
public static IBlockStatement GetRidOfStack(SourceMethodBody methodBody, IBlockStatement block) { var me = new Unstacker(methodBody); var result = me.Rewrite(block); var stmts = new List <IStatement>(); foreach (var loc in me.createdLocals.Values) { var decl = new LocalDeclarationStatement() { InitialValue = null, LocalVariable = loc, }; stmts.Add(decl); } stmts.AddRange(result.Statements); var newBlock = new BlockStatement() { Statements = stmts, Locations = new List <ILocation>(result.Locations), }; return(newBlock); }
public static Doc Print(SyntaxNode syntaxNode) { if (syntaxNode == null) { return(Doc.Null); } // TODO 0 kill? runtime repo has files that will fail on deep recursion if (depth > 200) { throw new InTooDeepException(); } depth++; try { switch (syntaxNode) { case AliasQualifiedNameSyntax aliasQualifiedNameSyntax: return(AliasQualifiedName.Print(aliasQualifiedNameSyntax)); case AnonymousMethodExpressionSyntax anonymousMethodExpressionSyntax: return(AnonymousMethodExpression.Print(anonymousMethodExpressionSyntax)); case AnonymousObjectCreationExpressionSyntax anonymousObjectCreationExpressionSyntax: return(AnonymousObjectCreationExpression.Print( anonymousObjectCreationExpressionSyntax )); case AnonymousObjectMemberDeclaratorSyntax anonymousObjectMemberDeclaratorSyntax: return(AnonymousObjectMemberDeclarator.Print( anonymousObjectMemberDeclaratorSyntax )); case ArgumentListSyntax argumentListSyntax: return(ArgumentList.Print(argumentListSyntax)); case ArgumentSyntax argumentSyntax: return(Argument.Print(argumentSyntax)); case ArrayCreationExpressionSyntax arrayCreationExpressionSyntax: return(ArrayCreationExpression.Print(arrayCreationExpressionSyntax)); case ArrayRankSpecifierSyntax arrayRankSpecifierSyntax: return(ArrayRankSpecifier.Print(arrayRankSpecifierSyntax)); case ArrayTypeSyntax arrayTypeSyntax: return(ArrayType.Print(arrayTypeSyntax)); case ArrowExpressionClauseSyntax arrowExpressionClauseSyntax: return(ArrowExpressionClause.Print(arrowExpressionClauseSyntax)); case AssignmentExpressionSyntax assignmentExpressionSyntax: return(AssignmentExpression.Print(assignmentExpressionSyntax)); case AttributeListSyntax attributeListSyntax: return(AttributeList.Print(attributeListSyntax)); case AwaitExpressionSyntax awaitExpressionSyntax: return(AwaitExpression.Print(awaitExpressionSyntax)); case BaseExpressionSyntax baseExpressionSyntax: return(BaseExpression.Print(baseExpressionSyntax)); case BaseFieldDeclarationSyntax baseFieldDeclarationSyntax: return(BaseFieldDeclaration.Print(baseFieldDeclarationSyntax)); case BaseListSyntax baseListSyntax: return(BaseList.Print(baseListSyntax)); case BaseMethodDeclarationSyntax baseMethodDeclarationSyntax: return(BaseMethodDeclaration.Print(baseMethodDeclarationSyntax)); case BasePropertyDeclarationSyntax basePropertyDeclarationSyntax: return(BasePropertyDeclaration.Print(basePropertyDeclarationSyntax)); case BaseTypeDeclarationSyntax baseTypeDeclarationSyntax: return(BaseTypeDeclaration.Print(baseTypeDeclarationSyntax)); case BinaryExpressionSyntax binaryExpressionSyntax: return(BinaryExpression.Print(binaryExpressionSyntax)); case BinaryPatternSyntax binaryPatternSyntax: return(BinaryPattern.Print(binaryPatternSyntax)); case BlockSyntax blockSyntax: return(Block.Print(blockSyntax)); case BracketedArgumentListSyntax bracketedArgumentListSyntax: return(BracketedArgumentList.Print(bracketedArgumentListSyntax)); case BracketedParameterListSyntax bracketedParameterListSyntax: return(BracketedParameterList.Print(bracketedParameterListSyntax)); case BreakStatementSyntax breakStatementSyntax: return(BreakStatement.Print(breakStatementSyntax)); case CasePatternSwitchLabelSyntax casePatternSwitchLabelSyntax: return(CasePatternSwitchLabel.Print(casePatternSwitchLabelSyntax)); case CaseSwitchLabelSyntax caseSwitchLabelSyntax: return(CaseSwitchLabel.Print(caseSwitchLabelSyntax)); case CastExpressionSyntax castExpressionSyntax: return(CastExpression.Print(castExpressionSyntax)); case CatchClauseSyntax catchClauseSyntax: return(CatchClause.Print(catchClauseSyntax)); case CheckedExpressionSyntax checkedExpressionSyntax: return(CheckedExpression.Print(checkedExpressionSyntax)); case CheckedStatementSyntax checkedStatementSyntax: return(CheckedStatement.Print(checkedStatementSyntax)); case ClassOrStructConstraintSyntax classOrStructConstraintSyntax: return(ClassOrStructConstraint.Print(classOrStructConstraintSyntax)); case CompilationUnitSyntax compilationUnitSyntax: return(CompilationUnit.Print(compilationUnitSyntax)); case ConditionalAccessExpressionSyntax conditionalAccessExpressionSyntax: return(ConditionalAccessExpression.Print(conditionalAccessExpressionSyntax)); case ConditionalExpressionSyntax conditionalExpressionSyntax: return(ConditionalExpression.Print(conditionalExpressionSyntax)); case ConstantPatternSyntax constantPatternSyntax: return(ConstantPattern.Print(constantPatternSyntax)); case ConstructorConstraintSyntax constructorConstraintSyntax: return(ConstructorConstraint.Print(constructorConstraintSyntax)); case ConstructorInitializerSyntax constructorInitializerSyntax: return(ConstructorInitializer.Print(constructorInitializerSyntax)); case ContinueStatementSyntax continueStatementSyntax: return(ContinueStatement.Print(continueStatementSyntax)); case DeclarationExpressionSyntax declarationExpressionSyntax: return(DeclarationExpression.Print(declarationExpressionSyntax)); case DeclarationPatternSyntax declarationPatternSyntax: return(DeclarationPattern.Print(declarationPatternSyntax)); case DefaultConstraintSyntax defaultConstraintSyntax: return(DefaultConstraint.Print(defaultConstraintSyntax)); case DefaultExpressionSyntax defaultExpressionSyntax: return(DefaultExpression.Print(defaultExpressionSyntax)); case DefaultSwitchLabelSyntax defaultSwitchLabelSyntax: return(DefaultSwitchLabel.Print(defaultSwitchLabelSyntax)); case DelegateDeclarationSyntax delegateDeclarationSyntax: return(DelegateDeclaration.Print(delegateDeclarationSyntax)); case DiscardDesignationSyntax discardDesignationSyntax: return(DiscardDesignation.Print(discardDesignationSyntax)); case DiscardPatternSyntax discardPatternSyntax: return(DiscardPattern.Print(discardPatternSyntax)); case DoStatementSyntax doStatementSyntax: return(DoStatement.Print(doStatementSyntax)); case ElementAccessExpressionSyntax elementAccessExpressionSyntax: return(ElementAccessExpression.Print(elementAccessExpressionSyntax)); case ElementBindingExpressionSyntax elementBindingExpressionSyntax: return(ElementBindingExpression.Print(elementBindingExpressionSyntax)); case ElseClauseSyntax elseClauseSyntax: return(ElseClause.Print(elseClauseSyntax)); case EmptyStatementSyntax emptyStatementSyntax: return(EmptyStatement.Print(emptyStatementSyntax)); case EnumMemberDeclarationSyntax enumMemberDeclarationSyntax: return(EnumMemberDeclaration.Print(enumMemberDeclarationSyntax)); case EqualsValueClauseSyntax equalsValueClauseSyntax: return(EqualsValueClause.Print(equalsValueClauseSyntax)); case ExpressionStatementSyntax expressionStatementSyntax: return(ExpressionStatement.Print(expressionStatementSyntax)); case ExternAliasDirectiveSyntax externAliasDirectiveSyntax: return(ExternAliasDirective.Print(externAliasDirectiveSyntax)); case FinallyClauseSyntax finallyClauseSyntax: return(FinallyClause.Print(finallyClauseSyntax)); case FixedStatementSyntax fixedStatementSyntax: return(FixedStatement.Print(fixedStatementSyntax)); case ForEachStatementSyntax forEachStatementSyntax: return(ForEachStatement.Print(forEachStatementSyntax)); case ForEachVariableStatementSyntax forEachVariableStatementSyntax: return(ForEachVariableStatement.Print(forEachVariableStatementSyntax)); case ForStatementSyntax forStatementSyntax: return(ForStatement.Print(forStatementSyntax)); case FromClauseSyntax fromClauseSyntax: return(FromClause.Print(fromClauseSyntax)); case FunctionPointerTypeSyntax functionPointerTypeSyntax: return(FunctionPointerType.Print(functionPointerTypeSyntax)); case GenericNameSyntax genericNameSyntax: return(GenericName.Print(genericNameSyntax)); case GlobalStatementSyntax globalStatementSyntax: return(GlobalStatement.Print(globalStatementSyntax)); case GotoStatementSyntax gotoStatementSyntax: return(GotoStatement.Print(gotoStatementSyntax)); case GroupClauseSyntax groupClauseSyntax: return(GroupClause.Print(groupClauseSyntax)); case IdentifierNameSyntax identifierNameSyntax: return(IdentifierName.Print(identifierNameSyntax)); case IfStatementSyntax ifStatementSyntax: return(IfStatement.Print(ifStatementSyntax)); case ImplicitArrayCreationExpressionSyntax implicitArrayCreationExpressionSyntax: return(ImplicitArrayCreationExpression.Print( implicitArrayCreationExpressionSyntax )); case ImplicitElementAccessSyntax implicitElementAccessSyntax: return(ImplicitElementAccess.Print(implicitElementAccessSyntax)); case ImplicitObjectCreationExpressionSyntax implicitObjectCreationExpressionSyntax: return(ImplicitObjectCreationExpression.Print( implicitObjectCreationExpressionSyntax )); case ImplicitStackAllocArrayCreationExpressionSyntax implicitStackAllocArrayCreationExpressionSyntax: return(ImplicitStackAllocArrayCreationExpression.Print( implicitStackAllocArrayCreationExpressionSyntax )); case IncompleteMemberSyntax incompleteMemberSyntax: return(IncompleteMember.Print(incompleteMemberSyntax)); case InitializerExpressionSyntax initializerExpressionSyntax: return(InitializerExpression.Print(initializerExpressionSyntax)); case InterpolatedStringExpressionSyntax interpolatedStringExpressionSyntax: return(InterpolatedStringExpression.Print( interpolatedStringExpressionSyntax )); case InterpolatedStringTextSyntax interpolatedStringTextSyntax: return(InterpolatedStringText.Print(interpolatedStringTextSyntax)); case InterpolationSyntax interpolationSyntax: return(Interpolation.Print(interpolationSyntax)); case InvocationExpressionSyntax invocationExpressionSyntax: return(InvocationExpression.Print(invocationExpressionSyntax)); case IsPatternExpressionSyntax isPatternExpressionSyntax: return(IsPatternExpression.Print(isPatternExpressionSyntax)); case JoinClauseSyntax joinClauseSyntax: return(JoinClause.Print(joinClauseSyntax)); case LabeledStatementSyntax labeledStatementSyntax: return(LabeledStatement.Print(labeledStatementSyntax)); case LetClauseSyntax letClauseSyntax: return(LetClause.Print(letClauseSyntax)); case LiteralExpressionSyntax literalExpressionSyntax: return(LiteralExpression.Print(literalExpressionSyntax)); case LocalDeclarationStatementSyntax localDeclarationStatementSyntax: return(LocalDeclarationStatement.Print(localDeclarationStatementSyntax)); case LocalFunctionStatementSyntax localFunctionStatementSyntax: return(LocalFunctionStatement.Print(localFunctionStatementSyntax)); case LockStatementSyntax lockStatementSyntax: return(LockStatement.Print(lockStatementSyntax)); case MakeRefExpressionSyntax makeRefExpressionSyntax: return(MakeRefExpression.Print(makeRefExpressionSyntax)); case MemberAccessExpressionSyntax memberAccessExpressionSyntax: return(MemberAccessExpression.Print(memberAccessExpressionSyntax)); case MemberBindingExpressionSyntax memberBindingExpressionSyntax: return(MemberBindingExpression.Print(memberBindingExpressionSyntax)); case NameColonSyntax nameColonSyntax: return(NameColon.Print(nameColonSyntax)); case NameEqualsSyntax nameEqualsSyntax: return(NameEquals.Print(nameEqualsSyntax)); case NamespaceDeclarationSyntax namespaceDeclarationSyntax: return(NamespaceDeclaration.Print(namespaceDeclarationSyntax)); case NullableTypeSyntax nullableTypeSyntax: return(NullableType.Print(nullableTypeSyntax)); case ObjectCreationExpressionSyntax objectCreationExpressionSyntax: return(ObjectCreationExpression.Print(objectCreationExpressionSyntax)); case OmittedArraySizeExpressionSyntax omittedArraySizeExpressionSyntax: return(OmittedArraySizeExpression.Print(omittedArraySizeExpressionSyntax)); case OmittedTypeArgumentSyntax omittedTypeArgumentSyntax: return(OmittedTypeArgument.Print(omittedTypeArgumentSyntax)); case OrderByClauseSyntax orderByClauseSyntax: return(OrderByClause.Print(orderByClauseSyntax)); case ParameterListSyntax parameterListSyntax: return(ParameterList.Print(parameterListSyntax)); case ParameterSyntax parameterSyntax: return(Parameter.Print(parameterSyntax)); case ParenthesizedExpressionSyntax parenthesizedExpressionSyntax: return(ParenthesizedExpression.Print(parenthesizedExpressionSyntax)); case ParenthesizedLambdaExpressionSyntax parenthesizedLambdaExpressionSyntax: return(ParenthesizedLambdaExpression.Print( parenthesizedLambdaExpressionSyntax )); case ParenthesizedPatternSyntax parenthesizedPatternSyntax: return(ParenthesizedPattern.Print(parenthesizedPatternSyntax)); case ParenthesizedVariableDesignationSyntax parenthesizedVariableDesignationSyntax: return(ParenthesizedVariableDesignation.Print( parenthesizedVariableDesignationSyntax )); case PointerTypeSyntax pointerTypeSyntax: return(PointerType.Print(pointerTypeSyntax)); case PostfixUnaryExpressionSyntax postfixUnaryExpressionSyntax: return(PostfixUnaryExpression.Print(postfixUnaryExpressionSyntax)); case PredefinedTypeSyntax predefinedTypeSyntax: return(PredefinedType.Print(predefinedTypeSyntax)); case PrefixUnaryExpressionSyntax prefixUnaryExpressionSyntax: return(PrefixUnaryExpression.Print(prefixUnaryExpressionSyntax)); case PrimaryConstructorBaseTypeSyntax primaryConstructorBaseTypeSyntax: return(PrimaryConstructorBaseType.Print(primaryConstructorBaseTypeSyntax)); case QualifiedNameSyntax qualifiedNameSyntax: return(QualifiedName.Print(qualifiedNameSyntax)); case QueryBodySyntax queryBodySyntax: return(QueryBody.Print(queryBodySyntax)); case QueryContinuationSyntax queryContinuationSyntax: return(QueryContinuation.Print(queryContinuationSyntax)); case QueryExpressionSyntax queryExpressionSyntax: return(QueryExpression.Print(queryExpressionSyntax)); case RangeExpressionSyntax rangeExpressionSyntax: return(RangeExpression.Print(rangeExpressionSyntax)); case RecursivePatternSyntax recursivePatternSyntax: return(RecursivePattern.Print(recursivePatternSyntax)); case RefExpressionSyntax refExpressionSyntax: return(RefExpression.Print(refExpressionSyntax)); case RefTypeExpressionSyntax refTypeExpressionSyntax: return(RefTypeExpression.Print(refTypeExpressionSyntax)); case RefTypeSyntax refTypeSyntax: return(RefType.Print(refTypeSyntax)); case RefValueExpressionSyntax refValueExpressionSyntax: return(RefValueExpression.Print(refValueExpressionSyntax)); case RelationalPatternSyntax relationalPatternSyntax: return(RelationalPattern.Print(relationalPatternSyntax)); case ReturnStatementSyntax returnStatementSyntax: return(ReturnStatement.Print(returnStatementSyntax)); case SelectClauseSyntax selectClauseSyntax: return(SelectClause.Print(selectClauseSyntax)); case SimpleBaseTypeSyntax simpleBaseTypeSyntax: return(SimpleBaseType.Print(simpleBaseTypeSyntax)); case SimpleLambdaExpressionSyntax simpleLambdaExpressionSyntax: return(SimpleLambdaExpression.Print(simpleLambdaExpressionSyntax)); case SingleVariableDesignationSyntax singleVariableDesignationSyntax: return(SingleVariableDesignation.Print(singleVariableDesignationSyntax)); case SizeOfExpressionSyntax sizeOfExpressionSyntax: return(SizeOfExpression.Print(sizeOfExpressionSyntax)); case StackAllocArrayCreationExpressionSyntax stackAllocArrayCreationExpressionSyntax: return(StackAllocArrayCreationExpression.Print( stackAllocArrayCreationExpressionSyntax )); case SwitchExpressionSyntax switchExpressionSyntax: return(SwitchExpression.Print(switchExpressionSyntax)); case SwitchSectionSyntax switchSectionSyntax: return(SwitchSection.Print(switchSectionSyntax)); case SwitchStatementSyntax switchStatementSyntax: return(SwitchStatement.Print(switchStatementSyntax)); case ThisExpressionSyntax thisExpressionSyntax: return(ThisExpression.Print(thisExpressionSyntax)); case ThrowExpressionSyntax throwExpressionSyntax: return(ThrowExpression.Print(throwExpressionSyntax)); case ThrowStatementSyntax throwStatementSyntax: return(ThrowStatement.Print(throwStatementSyntax)); case TryStatementSyntax tryStatementSyntax: return(TryStatement.Print(tryStatementSyntax)); case TupleElementSyntax tupleElementSyntax: return(TupleElement.Print(tupleElementSyntax)); case TupleExpressionSyntax tupleExpressionSyntax: return(TupleExpression.Print(tupleExpressionSyntax)); case TupleTypeSyntax tupleTypeSyntax: return(TupleType.Print(tupleTypeSyntax)); case TypeArgumentListSyntax typeArgumentListSyntax: return(TypeArgumentList.Print(typeArgumentListSyntax)); case TypeConstraintSyntax typeConstraintSyntax: return(TypeConstraint.Print(typeConstraintSyntax)); case TypeOfExpressionSyntax typeOfExpressionSyntax: return(TypeOfExpression.Print(typeOfExpressionSyntax)); case TypeParameterConstraintClauseSyntax typeParameterConstraintClauseSyntax: return(TypeParameterConstraintClause.Print( typeParameterConstraintClauseSyntax )); case TypeParameterListSyntax typeParameterListSyntax: return(TypeParameterList.Print(typeParameterListSyntax)); case TypeParameterSyntax typeParameterSyntax: return(TypeParameter.Print(typeParameterSyntax)); case TypePatternSyntax typePatternSyntax: return(TypePattern.Print(typePatternSyntax)); case UnaryPatternSyntax unaryPatternSyntax: return(UnaryPattern.Print(unaryPatternSyntax)); case UnsafeStatementSyntax unsafeStatementSyntax: return(UnsafeStatement.Print(unsafeStatementSyntax)); case UsingDirectiveSyntax usingDirectiveSyntax: return(UsingDirective.Print(usingDirectiveSyntax)); case UsingStatementSyntax usingStatementSyntax: return(UsingStatement.Print(usingStatementSyntax)); case VariableDeclarationSyntax variableDeclarationSyntax: return(VariableDeclaration.Print(variableDeclarationSyntax)); case VariableDeclaratorSyntax variableDeclaratorSyntax: return(VariableDeclarator.Print(variableDeclaratorSyntax)); case VarPatternSyntax varPatternSyntax: return(VarPattern.Print(varPatternSyntax)); case WhenClauseSyntax whenClauseSyntax: return(WhenClause.Print(whenClauseSyntax)); case WhereClauseSyntax whereClauseSyntax: return(WhereClause.Print(whereClauseSyntax)); case WhileStatementSyntax whileStatementSyntax: return(WhileStatement.Print(whileStatementSyntax)); case WithExpressionSyntax withExpressionSyntax: return(WithExpression.Print(withExpressionSyntax)); case YieldStatementSyntax yieldStatementSyntax: return(YieldStatement.Print(yieldStatementSyntax)); default: throw new Exception("Can't handle " + syntaxNode.GetType().Name); } } finally { depth--; } }
// For the first assignment to a local variable in a block before a control statement is hit, // if the local variable is not mentioned previously, we turn this assignment into a local declaration. private void AddDeclarationsWithInitialValues(IEnumerable <ILocalDefinition> localVariables, BasicBlock block) { List <ILocalDefinition> topLevelLocals = new List <ILocalDefinition>(localVariables); List <ILocalDefinition> localsMet = new List <ILocalDefinition>(); for (int i = 0; i < block.Statements.Count; i++) { if (topLevelLocals.Count == 0) { break; } IExpressionStatement expressionStatement = block.Statements[i] as IExpressionStatement; if (expressionStatement != null) { IAssignment assignment = expressionStatement.Expression as IAssignment; if (assignment != null) { ILocalDefinition localDef = assignment.Target.Definition as ILocalDefinition; if (localDef != null && topLevelLocals.Contains(localDef) && !localsMet.Contains(localDef) && !this.declaredLocals.ContainsKey(localDef)) { LocalDeclarationStatement localDecl = new LocalDeclarationStatement() { LocalVariable = localDef, InitialValue = assignment.Source, Locations = new List <ILocation>(expressionStatement.Locations), }; this.declaredLocals.Add(localDef, true); block.Statements[i] = localDecl; topLevelLocals.Remove(localDef); localsMet.Add(localDef); } } } LocalFinder finder = new LocalFinder(); finder.Traverse(block.Statements[i]); foreach (ILocalDefinition local in finder.FoundLocals) { if (!localsMet.Contains(local)) { localsMet.Add(local); } } //Once we see a statement that can transfer control somewhere else, we //no longer know that any subsequent assignment dominates all references //and hence cannot postpone adding the declaration until we can unify it with the assignment. IGotoStatement gotoStatement = block.Statements[i] as IGotoStatement; if (gotoStatement != null) { break; } IConditionalStatement conditionalStatement = block.Statements[i] as IConditionalStatement; if (conditionalStatement != null) { break; } ISwitchStatement switchStatement = block.Statements[i] as ISwitchStatement; if (switchStatement != null) { break; } IForEachStatement foreachStatement = block.Statements[i] as IForEachStatement; if (foreachStatement != null) { break; } IForStatement forStatement = block.Statements[i] as IForStatement; if (forStatement != null) { break; } ITryCatchFinallyStatement tryStatement = block.Statements[i] as ITryCatchFinallyStatement; if (tryStatement != null) { break; } } }
public override void RewriteChildren(MethodDefinition methodDefinition) { var methodContract = contractProvider.GetMethodContractFor(methodDefinition); if (methodContract == null) { return; } var sourceMethodBody = methodDefinition.Body as ISourceMethodBody; if (sourceMethodBody == null) { return; } var newStatements = new List <IStatement>(); var existingStatements = new List <IStatement>(sourceMethodBody.Block.Statements); existingStatements = Rewrite(existingStatements); // keep the call to the base constructor at the top if (methodDefinition.IsConstructor && existingStatements.Count > 0) { newStatements.Add(existingStatements[0]); existingStatements.RemoveAt(0); } /* if the query returns a value, instead of copying the postconditions at the end of each * single return in the code, we assign the value at that point to a local variable and jump * to the beginning of the postcondition block. */ // add a new local variable to store the value at return LocalDeclarationStatement retLocal = null; if (TypeHelper.GetTypeName(methodDefinition.Type) != TypeHelper.GetTypeName(host.PlatformType.SystemVoid)) { retLocal = new LocalDeclarationStatement { LocalVariable = new LocalDefinition { Name = host.NameTable.GetNameFor("retLocal"), Type = methodDefinition.Type }, InitialValue = new CompileTimeConstant { Type = methodDefinition.Type, Value = null } }; newStatements.Add(retLocal); } // add the preconditions as assumes foreach (var precondition in methodContract.Preconditions) { var methodCall = new MethodCall { Arguments = new List <IExpression> { Rewrite(precondition.Condition), precondition.Description ?? new CompileTimeConstant { Type = host.PlatformType.SystemString, Value = "Precondition" } }, IsStaticCall = true, MethodToCall = AssumeReference, Type = systemVoid, Locations = new List <ILocation>(precondition.Locations) }; var es = new ExpressionStatement { Expression = methodCall }; newStatements.Add(es); } // Add the invariant as a precondition as well var typeContract = contractProvider.GetTypeContractFor(methodDefinition.ContainingTypeDefinition); if (typeContract != null) { foreach (var inv in typeContract.Invariants) { var methodCall = new MethodCall { Arguments = new List <IExpression> { Rewrite(inv.Condition), new CompileTimeConstant { Value = "Type invariant", Type = host.PlatformType.SystemString } }, IsStaticCall = true, MethodToCall = AssumeReference, Type = systemVoid, Locations = new List <ILocation>(inv.Locations) }; var es = new ExpressionStatement { Expression = methodCall }; newStatements.Add(es); } } // the dummy statement is going to indicate the beginning of the postcondition block var dummyPostconditionStatement = new LabeledStatement { Label = host.NameTable.GetNameFor("dummyPostconditionStatement"), Statement = new EmptyStatement() }; var retRewriter = new ReturnRewriter(host, dummyPostconditionStatement, retLocal); //replace (nested) ReturnStatements with the GoTo to a single return at the end newStatements.AddRange(existingStatements.Select(stmt => retRewriter.Rewrite(stmt))); // now, that all the existing statements were added it is time for the postcondition block newStatements.Add(dummyPostconditionStatement); // Add assume statements for each postcondition that predicates ONLY about parameters (ie. not about the instance) var contractDependencyAnalyzer = new CciContractDependenciesAnalyzer(contractProvider); foreach (var postcondition in methodContract.Postconditions) { if (contractDependencyAnalyzer.PredicatesAboutInstance(postcondition) || !contractDependencyAnalyzer.PredicatesAboutParameter(postcondition)) { continue; } var methodCall = new MethodCall { Arguments = new List <IExpression> { Rewrite(postcondition.Condition), new CompileTimeConstant { Type = host.PlatformType.SystemString, Value = "Conditions over parameters are assumed satisfiable" } }, IsStaticCall = true, MethodToCall = AssumeReference, Type = systemVoid, Locations = new List <ILocation>(postcondition.Locations) }; var es = new ExpressionStatement { Expression = methodCall }; newStatements.Add(es); } // the postcondition block. Add each postcondition as an assert foreach (var postcondition in methodContract.Postconditions) { var methodCall = new MethodCall { Arguments = new List <IExpression> { Rewrite(postcondition.Condition), postcondition.Description ?? new CompileTimeConstant { Type = host.PlatformType.SystemString, Value = "Postcondition" } }, IsStaticCall = true, MethodToCall = AssertReference, Type = systemVoid, Locations = new List <ILocation>(postcondition.Locations) }; var es = new ExpressionStatement { Expression = methodCall }; newStatements.Add(es); } // add the invariant as a postcondition as well if (typeContract != null) { foreach (var inv in typeContract.Invariants) { var methodCall = new MethodCall { Arguments = new List <IExpression> { Rewrite(inv.Condition), new CompileTimeConstant { Value = "Type invariant", Type = host.PlatformType.SystemString } }, IsStaticCall = true, MethodToCall = AssertReference, Type = systemVoid, Locations = new List <ILocation>(inv.Locations) }; var es = new ExpressionStatement { Expression = methodCall }; newStatements.Add(es); } } IReturnStatement returnStatement; if (TypeHelper.GetTypeName(methodDefinition.Type) != TypeHelper.GetTypeName(host.PlatformType.SystemVoid)) { // If the method is not void, the return statement have to include the local variable returnStatement = new ReturnStatement { Expression = new BoundExpression { Definition = retLocal.LocalVariable, Instance = null, Type = retLocal.LocalVariable.Type } }; } else { returnStatement = new ReturnStatement(); } newStatements.Add(returnStatement); var newSourceMethodBody = new SourceMethodBody(host, sourceLocationProvider) { Block = new BlockStatement { Statements = newStatements }, IsNormalized = false, LocalsAreZeroed = sourceMethodBody.LocalsAreZeroed, MethodDefinition = methodDefinition }; methodDefinition.Body = newSourceMethodBody; }
public override void ExtendDeclaration(IDeclarationModel declaration, CompilationModel model) { // this only applies to methods var methodDecl = declaration as MethodDeclaration; if (methodDecl == null || methodDecl.Container == null) { return; } if (!methodDecl.Definition.Symbol.IsExtensionMethod) { throw new CompilationException("The ScriptMixin attribute can only be applied to extension methods.", declaration); } // remove the function from the container methodDecl.Container.RemoveMember(methodDecl); // get the extension target info var extTarget = methodDecl.Parameters[0]; var extType = extTarget.Definition.Type; // rewrite first param as a local declaration to this context var thisDecl = new LocalDeclarationStatement { VariableDeclaration = new VariableDeclaration() }; thisDecl.VariableDeclaration.Variables.Add(new VariableDeclarator { Definition = new LocalDefinition { Name = extTarget.Name, Type = extType }, EqualsValueExpression = new LiteralExpression { Text = "this" } }); // add the declaration to the method body methodDecl.Body.Statements.Insert(0, thisDecl); // create a lambda using the method body. var lambdaExpression = new LambdaExpression(); lambdaExpression.Body = methodDecl.Body; for (int i = 1; i < methodDecl.Parameters.Count; i++) { lambdaExpression.Parameters.Add(methodDecl.Parameters[i]); } // create a global statement to set the prototype value var target = extType.GetFullName() + ".prototype." + methodDecl.Definition.Name; model.GlobalStatements.Add(new ExpressionStatement { Expression = new BinaryExpression { LeftExpression = new LiteralExpression { Text = target }, RightExpression = lambdaExpression, Operator = "=" } }); }
public override IStatement Rewrite(IForEachStatement forEachStatement) { ILocalDefinition foreachLocal; var key = forEachStatement.Collection.Type.InternedKey; ITypeReference enumeratorType; IMethodReference getEnumerator; IMethodReference getCurrent; var gtir = forEachStatement.Collection.Type as IGenericTypeInstanceReference; if (gtir != null) { var typeArguments = gtir.GenericArguments; ITypeReference genericEnumeratorType = new Immutable.GenericTypeInstanceReference(this.host.PlatformType.SystemCollectionsGenericIEnumerator, typeArguments, this.host.InternFactory); ITypeReference genericEnumerableType = new Immutable.GenericTypeInstanceReference(this.host.PlatformType.SystemCollectionsGenericIEnumerable, typeArguments, this.host.InternFactory); enumeratorType = genericEnumeratorType; getEnumerator = new SpecializedMethodReference() { CallingConvention = CallingConvention.HasThis, ContainingType = genericEnumerableType, InternFactory = this.host.InternFactory, Name = this.host.NameTable.GetNameFor("GetEnumerator"), Parameters = new List <IParameterTypeInformation>(), Type = genericEnumeratorType, UnspecializedVersion = new MethodReference() { CallingConvention = CallingConvention.HasThis, ContainingType = this.host.PlatformType.SystemCollectionsGenericIEnumerable, InternFactory = this.host.InternFactory, Name = this.host.NameTable.GetNameFor("GetEnumerator"), Parameters = new List <IParameterTypeInformation>(), Type = this.host.PlatformType.SystemCollectionsGenericIEnumerator, }, }; var getEnumerator2 = (IMethodReference) IteratorHelper.First(genericEnumerableType.ResolvedType.GetMembersNamed(this.host.NameTable.GetNameFor("GetEnumerator"), false)); getEnumerator = getEnumerator2; getCurrent = (IMethodReference)IteratorHelper.First(genericEnumeratorType.ResolvedType.GetMembersNamed(this.host.NameTable.GetNameFor("get_Current"), false)); } else { enumeratorType = this.host.PlatformType.SystemCollectionsIEnumerator; getEnumerator = new MethodReference() { CallingConvention = CallingConvention.HasThis, ContainingType = enumeratorType, InternFactory = this.host.InternFactory, Name = this.host.NameTable.GetNameFor("GetEnumerator"), Parameters = new List <IParameterTypeInformation>(), Type = this.host.PlatformType.SystemCollectionsIEnumerable, }; getCurrent = new MethodReference() { CallingConvention = CallingConvention.HasThis, ContainingType = enumeratorType, InternFactory = this.host.InternFactory, Name = this.host.NameTable.GetNameFor("get_Current"), Parameters = new List <IParameterTypeInformation>(), Type = this.host.PlatformType.SystemObject, }; } var initializer = new MethodCall() { Arguments = new List <IExpression>(), IsStaticCall = false, IsVirtualCall = true, MethodToCall = getEnumerator, ThisArgument = forEachStatement.Collection, Type = enumeratorType, }; IStatement initialization; if (!this.foreachLocals.TryGetValue(key, out foreachLocal)) { foreachLocal = new LocalDefinition() { Type = enumeratorType, Name = this.host.NameTable.GetNameFor("CS$5$" + this.foreachLocals.Count) }; this.foreachLocals.Add(key, foreachLocal); initialization = new LocalDeclarationStatement() { InitialValue = initializer, LocalVariable = foreachLocal, }; } else { initialization = new ExpressionStatement() { Expression = new Assignment() { Source = initializer, Target = new TargetExpression() { Definition = foreachLocal, Instance = null, Type = foreachLocal.Type, }, Type = foreachLocal.Type, }, }; } var newStmts = new List <IStatement>(); newStmts.Add(new ExpressionStatement() { Expression = new Assignment() { Source = new MethodCall() { Arguments = new List <IExpression>(), IsStaticCall = false, IsVirtualCall = true, MethodToCall = getCurrent, ThisArgument = new BoundExpression() { Definition = foreachLocal, Instance = null, }, Type = forEachStatement.Variable.Type, }, Target = new TargetExpression() { Definition = forEachStatement.Variable, Instance = null, }, Type = forEachStatement.Variable.Type, }, }); newStmts.Add(forEachStatement.Body); var newBody = new BlockStatement() { Statements = newStmts, }; var result = new BlockStatement() { Statements = new List <IStatement>() { initialization, new TryCatchFinallyStatement() { TryBody = new BlockStatement() { Statements = new List <IStatement>() { new WhileDoStatement() { Body = newBody, Condition = new MethodCall() { Arguments = new List <IExpression>(), IsStaticCall = false, IsVirtualCall = true, MethodToCall = moveNext, ThisArgument = new BoundExpression() { Definition = foreachLocal, Instance = null, }, Type = this.host.PlatformType.SystemBoolean, }, }, }, }, FinallyBody = new BlockStatement() { Statements = new List <IStatement>() { new ConditionalStatement() { Condition = new Equality() { LeftOperand = new BoundExpression() { Definition = foreachLocal, Instance = null, Type = foreachLocal.Type, }, RightOperand = new CompileTimeConstant() { Type = foreachLocal.Type, Value = null, }, Type = this.host.PlatformType.SystemBoolean, }, FalseBranch = new EmptyStatement(), TrueBranch = new ExpressionStatement() { Expression = new MethodCall() { Arguments = new List <IExpression>(), IsStaticCall = false, IsVirtualCall = true, MethodToCall = this.disposeMethod, ThisArgument = new BoundExpression() { Definition = foreachLocal, Instance = null, }, Type = this.host.PlatformType.SystemVoid, }, }, }, }, }, }, }, }; return(result); }