public override object VisitIdentifierExpression(IdentifierExpression identifierExpression, object data)
        {
            base.VisitIdentifierExpression(identifierExpression, data);
            if (resolver.CompilationUnit == null)
            {
                return(null);
            }

            ResolveResult rr    = resolver.ResolveInternal(identifierExpression, ExpressionContext.Default);
            string        ident = GetIdentifierFromResult(rr);

            if (ident != null)
            {
                identifierExpression.Identifier = ident;
            }

            if (ReplaceWithInvocation(identifierExpression, rr))
            {
            }
            else if (FullyQualifyModuleMemberReference(identifierExpression, rr))
            {
            }
            else if (FullyQualifyNamespaceReference(identifierExpression, rr))
            {
            }

            return(null);
        }
コード例 #2
0
        public override IReturnType ResolveReturnType()
        {
            MemberLookupHelper.Log("LambdaReturnType: ResolveReturnType");
            IReturnType result;

            if (returnExpressions.Count == 0)
            {
                result = resolver.ProjectContent.SystemTypes.Void;
            }
            else
            {
                result = returnExpressions.Select(rt => resolver.ResolveInternal(rt, ExpressionContext.Default))
                         .Select(rr => rr != null ? rr.ResolvedType : null)
                         .Aggregate((rt1, rt2) => MemberLookupHelper.GetCommonType(resolver.ProjectContent, rt1, rt2));
            }
            MemberLookupHelper.Log("LambdaReturnType: inferred " + result);
            return(result);
        }
コード例 #3
0
        public override object VisitExpressionStatement(ExpressionStatement expressionStatement, object data)
        {
            if (resolver.CompilationUnit == null)
            {
                return(base.VisitExpressionStatement(expressionStatement, data));
            }

            // Transform event invocations that aren't already transformed by a parent IfStatement to RaiseEvent statement
            InvocationExpression eventInvocation = expressionStatement.Expression as InvocationExpression;

            if (eventInvocation != null && eventInvocation.TargetObject is IdentifierExpression)
            {
                MemberResolveResult mrr = resolver.ResolveInternal(eventInvocation.TargetObject, ExpressionContext.Default) as MemberResolveResult;
                if (mrr != null && mrr.ResolvedMember is IEvent)
                {
                    ReplaceCurrentNode(new RaiseEventStatement(
                                           ((IdentifierExpression)eventInvocation.TargetObject).Identifier,
                                           eventInvocation.Arguments));
                }
            }
            base.VisitExpressionStatement(expressionStatement, data);

            HandleAssignmentStatement(expressionStatement.Expression as AssignmentExpression);
            return(null);
        }