示例#1
0
        private string TransformLocal(LocalSymbol localSymbol)
        {
            int depth = 0;

            AnonymousMethodSymbol parentMethod = localSymbol.Parent as AnonymousMethodSymbol;

            if (parentMethod != null)
            {
                // If an anonymous method contains a local variable with the
                // same name as a variable in the containing method, they will
                // conflict at runtime, i.e. the value in the inner method
                // will override the value of the outer method when it is run.
                // Note that right now we aren't seeing if there is actually a conflict.
                // We're always qualifying the inner variable with a depth prefix.
                // REVIEW: Should we try to optimize when we qualify?

                depth = parentMethod.Depth;
            }

            string transformedName = GenerateName(_count, depth);

            _count++;

            return(transformedName);
        }
示例#2
0
        public virtual void AddAnonymousMethod(AnonymousMethodSymbol anonymousMethod) {
            Debug.Assert(anonymousMethod != null);

            if (_anonymousMethods == null) {
                _anonymousMethods = new List<AnonymousMethodSymbol>();
            }

            _anonymousMethods.Add(anonymousMethod);
        }
示例#3
0
        public virtual void AddAnonymousMethod(AnonymousMethodSymbol anonymousMethod)
        {
            Debug.Assert(anonymousMethod != null);

            if (_anonymousMethods == null)
            {
                _anonymousMethods = new List <AnonymousMethodSymbol>();
            }

            _anonymousMethods.Add(anonymousMethod);
        }
 public SymbolImplementation BuildMethod(AnonymousMethodSymbol methodSymbol)
 {
     BlockStatementNode methodBody = ((AnonymousMethodNode)methodSymbol.ParseContext).Implementation;
     return BuildImplementation(methodSymbol.StackContext,
                                methodSymbol, methodBody, /* addAllParameters */ true);
 }
 public override void AddAnonymousMethod(AnonymousMethodSymbol anonymousMethod) {
     _containingMember.AddAnonymousMethod(anonymousMethod);
 }
 public override void AddAnonymousMethod(AnonymousMethodSymbol anonymousMethod)
 {
     _containingMember.AddAnonymousMethod(anonymousMethod);
 }
示例#7
0
 public static void GenerateScript(ScriptGenerator generator, AnonymousMethodSymbol symbol) {
     GenerateImplementationScript(generator, symbol, symbol.Implementation);
 }
示例#8
0
        private Expression ProcessAnonymousMethodNode(AnonymousMethodNode node) {
            TypeSymbol voidType = _symbolSet.ResolveIntrinsicType(IntrinsicType.Void);
            Debug.Assert(voidType != null);

            bool createStaticDelegate = (_memberContext.Visibility & MemberVisibility.Static) != 0;

            AnonymousMethodSymbol methodSymbol =
                new AnonymousMethodSymbol(_memberContext, _symbolTable, voidType, createStaticDelegate);
            methodSymbol.SetParseContext(node);

            if ((node.Parameters != null) && (node.Parameters.Count != 0)) {
                foreach (ParameterNode parameterNode in node.Parameters) {
                    TypeSymbol parameterType = _symbolSet.ResolveType(parameterNode.Type, _symbolTable, _symbolContext);
                    Debug.Assert(parameterType != null);

                    ParameterSymbol paramSymbol =
                        new ParameterSymbol(parameterNode.Name, methodSymbol, parameterType, ParameterMode.In);
                    if (paramSymbol != null) {
                        paramSymbol.SetParseContext(parameterNode);
                        methodSymbol.AddParameter(paramSymbol);
                    }
                }
            }

            ImplementationBuilder implBuilder = new ImplementationBuilder(_options, _errorHandler);
            SymbolImplementation implementation = implBuilder.BuildMethod(methodSymbol);

            methodSymbol.AddImplementation(implementation);

            if ((createStaticDelegate == false) && (implementation.RequiresThisContext == false)) {
                methodSymbol.SetVisibility(methodSymbol.Visibility | MemberVisibility.Static);
                createStaticDelegate = true;
            }

            Expression objectExpression;
            if (createStaticDelegate) {
                TypeSymbol objectType = _symbolSet.ResolveIntrinsicType(IntrinsicType.Object);
                Debug.Assert(objectType != null);

                objectExpression = new LiteralExpression(objectType, null);
            }
            else {
                objectExpression = new ThisExpression(_classContext, /* explicitReference */ true);
            }

            return new DelegateExpression(objectExpression, methodSymbol);
        }