示例#1
0
        static void _Patch(CodeDelegateInvokeExpression di, CodeDomVisitContext ctx, CodeDomResolver resolver)
        {
            if (null != di)
            {
                // these can be method invokes depending.
                if (null != di.TargetObject)
                {
                    // probably already fixed in an earlier visit
                    var mr = di.TargetObject as CodeMethodReferenceExpression;
                    if (null != mr)
                    {
                        var mi = new CodeMethodInvokeExpression(mr);
                        mi.Parameters.AddRange(di.Parameters);
                        CodeDomVisitor.ReplaceTarget(ctx, mi);

                        //args.Cancel = true;
                    }
                    else
                    {
                        var cco = di.TargetObject as CodeObject;
                        if (null == cco)
                        {
                            System.Diagnostics.Debugger.Break();
                        }
                    }
                }
                else
                {
                    // we really are at a loss here as the only way this would be valid is
                    // through a self call on a delegate object itself, like this();
                    throw new InvalidProgramException(_AppendLineInfo("Untargeted delegate invoke produced by slang parser", di));
                }
                //return;
            }
        }
示例#2
0
 static void _Patch(CodeAssignStatement ast, CodeDomVisitContext ctx, CodeDomResolver res)
 {
     if (null != ast)
     {
         var eventRef = ast.Left as CodeEventReferenceExpression;
         if (null != eventRef)
         {
             var bo = ast.Right as CodeBinaryOperatorExpression;
             if (null != bo)
             {
                 var trg = bo.Right;
                 if (CodeBinaryOperatorType.Add == bo.Operator)
                 {
                     CodeDomVisitor.ReplaceTarget(ctx, new CodeAttachEventStatement(eventRef, trg));
                 }
                 else if (CodeBinaryOperatorType.Subtract == bo.Operator)
                 {
                     CodeDomVisitor.ReplaceTarget(ctx, new CodeRemoveEventStatement(eventRef, trg));
                 }
             }
         }
         else if (!ast.Left.UserData.Contains("slang:unresolved"))
         {
             ast.UserData.Remove("slang:unresolved");
         }
     }
 }
示例#3
0
        static void _Patch(CodeMemberProperty prop, CodeDomVisitContext ctx, CodeDomResolver resolver)
        {
            if (null != prop)
            {
                // TODO: make sure the member is actually public
                if (null == prop.PrivateImplementationType)
                {
                    var scope  = resolver.GetScope(prop);
                    var td     = scope.DeclaringType;
                    var binder = new CodeDomBinder(scope);
                    for (int ic = td.BaseTypes.Count, i = 0; i < ic; ++i)
                    {
                        var ctr = td.BaseTypes[i];
                        var t   = resolver.TryResolveType(ctr, scope);
                        if (null != t)
                        {
                            var ma = binder.GetPropertyGroup(t, prop.Name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);
                            if (0 < ma.Length)
                            {
                                var p = binder.SelectProperty(BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly, ma, null, _GetParameterTypes(prop.Parameters), null);
                                if (null != p)
                                {
                                    prop.ImplementationTypes.Add(ctr);
                                }
                            }
                        }
                    }
                }

                prop.UserData.Remove("slang:unresolved");
            }
        }
 static void _Patch(CodeMemberMethod meth, CodeDomVisitContext ctx, CodeDomResolver resolver)
 {
     if (null != meth)
     {
         // TODO: Populate public implementation types
         meth.UserData.Remove("slang:unresolved");
         if ("Main" == meth.Name && (meth.Attributes & MemberAttributes.ScopeMask) == MemberAttributes.Static)
         {
             if (0 == meth.Parameters.Count && null == meth.ReturnType || "System.Void" == meth.ReturnType.BaseType)
             {
                 var epm = new CodeEntryPointMethod();
                 epm.Attributes = meth.Attributes;
                 epm.LinePragma = meth.LinePragma;
                 epm.StartDirectives.AddRange(meth.StartDirectives);
                 epm.EndDirectives.AddRange(meth.EndDirectives);
                 epm.Comments.AddRange(meth.Comments);
                 epm.CustomAttributes.AddRange(meth.CustomAttributes);
                 epm.ReturnTypeCustomAttributes.AddRange(meth.ReturnTypeCustomAttributes);
                 epm.TypeParameters.AddRange(meth.TypeParameters);
                 epm.PrivateImplementationType = meth.PrivateImplementationType;
                 epm.ImplementationTypes.AddRange(meth.ImplementationTypes);
                 epm.Name = meth.Name;
                 epm.Statements.AddRange(meth.Statements);
                 CodeDomVisitor.ReplaceTarget(ctx, epm);
             }
         }
         //return;
     }
 }
 static void _Patch(CodeMemberProperty prop, CodeDomVisitContext ctx, CodeDomResolver resolver)
 {
     if (null != prop)
     {
         // TODO: add public implementation types
         prop.UserData.Remove("slang:unresolved");
     }
 }
 static void _Patch(CodeTypeReference tr, CodeDomVisitContext ctx, CodeDomResolver res)
 {
     if (null != tr)
     {
         if (res.IsValidType(tr, res.GetScope(tr)))
         {
             tr.UserData.Remove("slang:unresolved");
             return;
         }
         // this is probably a nested type but with . instead of +
         // so now we need to crack it apart and hunt it down
         throw new NotImplementedException();
     }
 }
示例#7
0
 static void _Patch(CodeObjectCreateExpression oc, CodeDomVisitContext ctx, CodeDomResolver res)
 {
     if (null != oc)             // we have to check to see if this is a delegate creation expression
     {
         oc.UserData.Remove("slang:unresolved");
         if (1 == oc.Parameters.Count)
         {
             if (_IsDelegate(oc.Parameters[0], res))
             {
                 var del = _GetDelegateFromFields(oc, oc.Parameters[0], res);
                 CodeDomVisitor.ReplaceTarget(ctx, del);
             }
         }
     }
 }
示例#8
0
 static void _Patch(CodeTypeReferenceExpression tr, CodeDomVisitContext ctx, CodeDomResolver res)
 {
     if (null != tr)
     {
         if (res.IsValidType(tr.Type))
         {
             tr.Type.UserData.Remove("slang:unresolved");
             tr.UserData.Remove("slang:unresolved");
         }
         else
         {
             // TODO: Check for nested type.
             throw new ArgumentException(_AppendLineInfo(string.Format("Unable to resolve type {0}", tr.Type.BaseType), tr.Type), "compileUnits");
         }
     }
 }
示例#9
0
        static void _Patch(CodeIndexerExpression indexer, CodeDomVisitContext ctx, CodeDomResolver resolver)
        {
            if (null != indexer)
            {
                if (indexer.TargetObject.UserData.Contains("slang:unresolved"))
                {
                    return;
                }

                var ctr = resolver.GetTypeOfExpression(indexer.TargetObject);
                if (null != ctr.ArrayElementType && 0 < ctr.ArrayRank)
                {
                    var ai = new CodeArrayIndexerExpression(indexer.TargetObject);
                    ai.Indices.AddRange(indexer.Indices);
                    CodeDomVisitor.ReplaceTarget(ctx, ai);

                    //return;
                }
                indexer.UserData.Remove("slang:unresolved");
            }
        }
示例#10
0
        static void _Patch(CodeVariableDeclarationStatement vd, CodeDomVisitContext ctx, CodeDomResolver resolver)
        {
            if (null != vd)
            {
                if (CodeDomResolver.IsNullOrVoidType(vd.Type) || (0 == vd.Type.ArrayRank && 0 == vd.Type.TypeArguments.Count && 0 == string.Compare("var", vd.Type.BaseType, StringComparison.InvariantCulture)))
                {
                    if (null == vd.InitExpression)
                    {
                        throw new ArgumentException(_AppendLineInfo("The code contains an incomplete variable declaration", vd), "resolver");
                    }
                    if (!_HasUnresolved(vd.InitExpression))
                    {
                        var t = resolver.GetTypeOfExpression(vd.InitExpression, resolver.GetScope(vd.InitExpression));

                        vd.Type = t;
                        if (!CodeDomResolver.IsNullOrVoidType(t))
                        {
                            vd.UserData.Remove("slang:unresolved");
                        }
                    }
                }
            }
        }
        static void _Patch(CodeVariableDeclarationStatement vd, CodeDomVisitContext ctx, CodeDomResolver resolver)
        {
            if (null != vd)
            {
                if (CodeDomResolver.IsNullOrVoidType(vd.Type))
                {
                    if (null == vd.InitExpression)
                    {
                        throw new ArgumentException("The code contains an incomplete variable declaration.", "resolver");
                    }
                    if (!_HasUnresolved(vd.InitExpression))
                    {
                        var t = resolver.GetTypeOfExpression(vd.InitExpression, resolver.GetScope(vd.InitExpression));

                        vd.Type = t;
                        if (!CodeDomResolver.IsNullOrVoidType(t))
                        {
                            vd.UserData.Remove("slang:unresolved");
                        }
                    }
                }
            }
        }
示例#12
0
 static void _Patch(CodeFieldReferenceExpression fr, CodeDomVisitContext ctx, CodeDomResolver resolver)
 {
     if (null != fr)
     {
         // this probably means part of our field has been resolved, or at the very least
         // it does not come from a rooted var ref.
         if (!fr.TargetObject.UserData.Contains("slang:unresolved"))
         {
             var scope  = resolver.GetScope(fr);
             var binder = new CodeDomBinder(scope);
             var t      = resolver.GetTypeOfExpression(fr.TargetObject, scope);
             if (null != t && CodeDomResolver.IsNullOrVoidType(t) && fr.TargetObject is CodeVariableReferenceExpression)
             {
                 return;                         // can't patch this field yet - it's part of a var reference that hasn't been filled in
             }
             var isStatic = false;
             var tre      = fr.TargetObject as CodeTypeReferenceExpression;
             if (null != tre)
             {
                 isStatic = true;
             }
             var tt = resolver.TryResolveType(isStatic ? tre.Type : t, scope, true);
             if (null == tt)
             {
                 throw new InvalidOperationException(_AppendLineInfo(string.Format("The type {0} could not be resolved", t.BaseType), t));
             }
             var td = tt as CodeTypeDeclaration;
             // TODO: This code could be a lot faster if we added some functionality to the binder
             // we're just checking to see if the method, property or field exists
             var m = binder.GetField(tt, fr.FieldName, _BindFlags);
             if (null != m)
             {
                 fr.UserData.Remove("slang:unresolved");
                 return;
             }
             m = binder.GetEvent(tt, fr.FieldName, _BindFlags);
             if (null != m)
             {
                 var er = new CodeEventReferenceExpression(fr.TargetObject, fr.FieldName);
                 CodeDomVisitor.ReplaceTarget(ctx, er);
                 return;
             }
             var ml = binder.GetMethodGroup(tt, fr.FieldName, _BindFlags);
             if (0 < ml.Length)
             {
                 var mr = new CodeMethodReferenceExpression(fr.TargetObject, fr.FieldName);
                 CodeDomVisitor.ReplaceTarget(ctx, mr);
                 return;
             }
             ml = binder.GetPropertyGroup(tt, fr.FieldName, _BindFlags);
             if (0 < ml.Length)
             {
                 var pr = new CodePropertyReferenceExpression(fr.TargetObject, fr.FieldName);
                 CodeDomVisitor.ReplaceTarget(ctx, pr);
                 return;
             }
             throw new InvalidProgramException(_AppendLineInfo(string.Format("Cannot deterimine the target reference {0}", fr.FieldName), fr));
         }
         // TODO: This used to be first but I moved it here.
         // This shouldn't be done first because it's resolving types before fields and
         // that is a no no. I still need to make sure it doesn't break things
         var path = _GetUnresRootPathOfExpression(fr);
         if (null != path)
         {
             // now we have something to work with.
             var scope = resolver.GetScope(fr);
             var sa    = path.Split('.');
             if (1 == sa.Length)
             {
                 System.Diagnostics.Debugger.Break();
                 throw new NotImplementedException();
             }
             else
             {
                 object            t   = null;
                 string            tn  = null;
                 CodeExpression    tf  = fr;
                 CodeExpression    ptf = null;
                 CodeTypeReference ctr = null;
                 for (var i = sa.Length - 1; i >= 1; --i)
                 {
                     tn  = string.Join(".", sa, 0, i);
                     ptf = tf;
                     tf  = _GetTargetOfExpression(tf);
                     ctr = new CodeTypeReference(tn);
                     t   = resolver.TryResolveType(ctr, scope);
                     if (null != t)
                     {
                         break;
                     }
                 }
                 if (null != t)
                 {
                     var tt = t as Type;
                     if (null != tt)
                     {
                         ctr = new CodeTypeReference(tt);
                     }
                     else
                     {
                         ctr = resolver.GetQualifiedType(ctr, scope);
                     }
                     // we found a type reference
                     _SetTargetOfExpression(ptf, new CodeTypeReferenceExpression(ctr));
                     return;
                     //args.Cancel = true;
                 }
             }
         }
     }
 }
示例#13
0
        static void _Patch(CodeVariableReferenceExpression vr, CodeDomVisitContext ctx, CodeDomResolver resolver)
        {
            if (null != vr)
            {
                var scope = resolver.GetScope(vr);
                if (0 == string.Compare("value", vr.VariableName, StringComparison.InvariantCulture))
                {
                    // this could be a property set value reference
                    var p = scope.Member as CodeMemberProperty;
                    if (null != p)
                    {
                        var found = false;
                        for (int ic = p.SetStatements.Count, i = 0; i < ic; ++i)
                        {
                            found = false;
                            CodeDomVisitor.Visit(p.SetStatements[i], (ctx2) => {
                                if (ctx2.Target == vr)
                                {
                                    found       = true;
                                    ctx2.Cancel = true;
                                }
                            });
                            if (found)
                            {
                                break;
                            }
                        }
                        if (found)
                        {
                            CodeDomVisitor.ReplaceTarget(ctx, new CodePropertySetValueReferenceExpression());
                            return;
                        }
                    }
                }
                CodeTypeReference ctr;
                if (scope.VariableTypes.TryGetValue(vr.VariableName, out ctr))
                {
                    if (!CodeDomResolver.IsNullOrVoidType(ctr))
                    {
                        vr.UserData.Remove("slang:unresolved");
                        return;
                    }
                }
                // we need to replace it.
                if (scope.ArgumentTypes.ContainsKey(vr.VariableName))
                {
                    var a = new CodeArgumentReferenceExpression(vr.VariableName);
                    CodeDomVisitor.ReplaceTarget(ctx, a);
                    return;
                    //args.Cancel = true;
                }
                else if (scope.FieldNames.Contains(vr.VariableName))
                {
                    CodeTypeReference tref;
                    // find out where it belongs.
                    if (scope.ThisTargets.Contains(vr.VariableName))
                    {
                        var f = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), vr.VariableName);
                        CodeDomVisitor.ReplaceTarget(ctx, f);
                        //return;
                    }
                    else if (scope.TypeTargets.TryGetValue(vr.VariableName, out tref))
                    {
                        var f = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(tref), vr.VariableName);
                        CodeDomVisitor.ReplaceTarget(ctx, f);
                        //return;
                    }

                    return;
                }
                else if (scope.MethodNames.Contains(vr.VariableName))
                {
                    CodeTypeReference tref;
                    // find out where it belongs.
                    if (scope.ThisTargets.Contains(vr.VariableName))
                    {
                        var m = new CodeMethodReferenceExpression(new CodeThisReferenceExpression(), vr.VariableName);
                        CodeDomVisitor.ReplaceTarget(ctx, m);
                        return;
                        //args.Cancel = true;
                    }
                    if (scope.TypeTargets.TryGetValue(vr.VariableName, out tref))
                    {
                        var m = new CodeMethodReferenceExpression(new CodeTypeReferenceExpression(tref), vr.VariableName);
                        CodeDomVisitor.ReplaceTarget(ctx, m);
                        return;
                        //args.Cancel = true;
                    }
                }
                else if (scope.PropertyNames.Contains(vr.VariableName))
                {
                    CodeTypeReference tref;
                    // find out where it belongs.
                    if (scope.ThisTargets.Contains(vr.VariableName))
                    {
                        var p = new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), vr.VariableName);
                        CodeDomVisitor.ReplaceTarget(ctx, p);
                        return;
                        //args.Cancel = true;
                    }
                    else if (scope.TypeTargets.TryGetValue(vr.VariableName, out tref))
                    {
                        var p = new CodePropertyReferenceExpression(new CodeTypeReferenceExpression(tref), vr.VariableName);
                        CodeDomVisitor.ReplaceTarget(ctx, p);
                        return;
                        //args.Cancel = true;
                    }
                }
                else if (scope.EventNames.Contains(vr.VariableName))
                {
                    CodeTypeReference tref;
                    // find out where it belongs.
                    if (scope.ThisTargets.Contains(vr.VariableName))
                    {
                        var e = new CodeEventReferenceExpression(new CodeThisReferenceExpression(), vr.VariableName);
                        CodeDomVisitor.ReplaceTarget(ctx, e);
                        return;
                        //args.Cancel = true;
                    }
                    else if (scope.TypeTargets.TryGetValue(vr.VariableName, out tref))
                    {
                        var e = new CodeEventReferenceExpression(new CodeTypeReferenceExpression(tref), vr.VariableName);
                        CodeDomVisitor.ReplaceTarget(ctx, e);
                        return;
                        //args.Cancel = true;
                    }
                }
                return;
            }
            return;
        }
示例#14
0
        static void _Patch(CodeMemberMethod meth, CodeDomVisitContext ctx, CodeDomResolver resolver)
        {
            if (null != meth)
            {
                // TODO: make sure the member is actually public
                if (null == meth.PrivateImplementationType)
                {
                    var scope  = resolver.GetScope(meth);
                    var td     = scope.DeclaringType;
                    var binder = new CodeDomBinder(scope);
                    for (int ic = td.BaseTypes.Count, i = 0; i < ic; ++i)
                    {
                        var ctr = td.BaseTypes[i];
                        var t   = resolver.TryResolveType(ctr, scope);
                        if (null != t)
                        {
                            var ma = binder.GetMethodGroup(t, meth.Name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);
                            if (0 < ma.Length)
                            {
                                var isIface = false;
                                var ttd     = t as CodeTypeDeclaration;
                                if (null != ttd)
                                {
                                    isIface = ttd.IsInterface;
                                }
                                else
                                {
                                    var rrt = t as Type;
                                    isIface = rrt.IsInterface;
                                }
                                if (isIface)
                                {
                                    var m = binder.SelectMethod(BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly, ma, _GetParameterTypes(meth.Parameters), null);
                                    if (null != m)
                                    {
                                        meth.ImplementationTypes.Add(ctr);
                                    }
                                }
                            }
                        }
                    }
                }

                meth.UserData.Remove("slang:unresolved");
                if ("Main" == meth.Name && (meth.Attributes & MemberAttributes.ScopeMask) == MemberAttributes.Static)
                {
                    if (0 == meth.Parameters.Count && null == meth.ReturnType || "System.Void" == meth.ReturnType.BaseType)
                    {
                        var epm = new CodeEntryPointMethod();
                        epm.Attributes = meth.Attributes;
                        epm.LinePragma = meth.LinePragma;
                        epm.StartDirectives.AddRange(meth.StartDirectives);
                        epm.EndDirectives.AddRange(meth.EndDirectives);
                        epm.Comments.AddRange(meth.Comments);
                        epm.CustomAttributes.AddRange(meth.CustomAttributes);
                        epm.ReturnTypeCustomAttributes.AddRange(meth.ReturnTypeCustomAttributes);
                        epm.TypeParameters.AddRange(meth.TypeParameters);
                        epm.PrivateImplementationType = meth.PrivateImplementationType;
                        epm.ImplementationTypes.AddRange(meth.ImplementationTypes);
                        epm.Name = meth.Name;
                        epm.Statements.AddRange(meth.Statements);
                        CodeDomVisitor.ReplaceTarget(ctx, epm);
                    }
                }
                //return;
            }
        }
示例#15
0
        static void _Patch(CodeBinaryOperatorExpression op, CodeDomVisitContext ctx, CodeDomResolver resolver)
        {
            if (null != op)
            {
                //var rf = op.Left as CodeFieldReferenceExpression;
                //if (null != rf && rf.FieldName == "Reduce")
                //	System.Diagnostics.Debugger.Break();
                var scope = resolver.GetScope(op);
                if (CodeBinaryOperatorType.IdentityEquality == op.Operator)
                {
                    if (_HasUnresolved(op.Left))
                    {
                        return;
                    }
                    //var vop = op.Right as CodeVariableReferenceExpression;
                    //if (null != vop && vop.VariableName == "n")
                    //	System.Diagnostics.Debugger.Break();

                    var tr1 = resolver.GetTypeOfExpression(op.Left);
                    if (resolver.IsValueType(tr1))
                    {
                        if (_HasUnresolved(op.Right))
                        {
                            return;
                        }
                        var tr2 = resolver.GetTypeOfExpression(op.Right);
                        if (resolver.IsValueType(tr2))
                        {
                            var op2 = new CodeBinaryOperatorExpression(op.Left, CodeBinaryOperatorType.ValueEquality, op.Right);
                            CodeDomVisitor.ReplaceTarget(ctx, op2);
                            return;
                        }
                    }
                    op.UserData.Remove("slang:unresolved");
                }
                else if (CodeBinaryOperatorType.IdentityInequality == op.Operator)
                {
                    if (_HasUnresolved(op.Left))
                    {
                        return;
                    }
                    var tr1 = resolver.GetTypeOfExpression(op.Left);
                    if (resolver.IsValueType(tr1))
                    {
                        if (_HasUnresolved(op.Right))
                        {
                            return;
                        }
                        var tr2 = resolver.GetTypeOfExpression(op.Right);
                        if (resolver.IsValueType(tr2))
                        {
                            // we have to hack the codedom because there is no value inequality
                            op.Operator = CodeBinaryOperatorType.ValueEquality;
                            var newOp = new CodeBinaryOperatorExpression(new CodePrimitiveExpression(false), CodeBinaryOperatorType.ValueEquality, op);
                            CodeDomVisitor.ReplaceTarget(ctx, newOp);
                        }
                    }
                    op.UserData.Remove("slang:unresolved");
                }
            }
        }
        static void _Patch(CodeVariableReferenceExpression vr, CodeDomVisitContext ctx, CodeDomResolver resolver)
        {
            if (null != vr)
            {
                if ("NodeFlags" == vr.VariableName)
                {
                    System.Diagnostics.Debugger.Break();
                }
                var scope = resolver.GetScope(vr);
                if (scope.VariableTypes.ContainsKey(vr.VariableName))
                {
                    vr.UserData.Remove("slang:unresolved");
                    return;
                }
                // we need to replace it.
                if (scope.ArgumentTypes.ContainsKey(vr.VariableName))
                {
                    var a = new CodeArgumentReferenceExpression(vr.VariableName);
                    CodeDomVisitor.ReplaceTarget(ctx, a);
                    return;
                    //args.Cancel = true;
                }
                else if (scope.FieldNames.Contains(vr.VariableName))
                {
                    CodeTypeReference tref;
                    // find out where it belongs.
                    if (scope.ThisTargets.Contains(vr.VariableName))
                    {
                        var f = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), vr.VariableName);
                        CodeDomVisitor.ReplaceTarget(ctx, f);
                        //return;
                    }
                    else if (scope.TypeTargets.TryGetValue(vr.VariableName, out tref))
                    {
                        var f = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(tref), vr.VariableName);
                        CodeDomVisitor.ReplaceTarget(ctx, f);
                        //return;
                    }

                    return;
                }
                else if (scope.MethodNames.Contains(vr.VariableName))
                {
                    CodeTypeReference tref;
                    // find out where it belongs.
                    if (scope.ThisTargets.Contains(vr.VariableName))
                    {
                        var m = new CodeMethodReferenceExpression(new CodeThisReferenceExpression(), vr.VariableName);
                        CodeDomVisitor.ReplaceTarget(ctx, m);
                        return;
                        //args.Cancel = true;
                    }
                    if (scope.TypeTargets.TryGetValue(vr.VariableName, out tref))
                    {
                        var m = new CodeMethodReferenceExpression(new CodeTypeReferenceExpression(tref), vr.VariableName);
                        CodeDomVisitor.ReplaceTarget(ctx, m);
                        return;
                        //args.Cancel = true;
                    }
                }
                else if (scope.PropertyNames.Contains(vr.VariableName))
                {
                    CodeTypeReference tref;
                    // find out where it belongs.
                    if (scope.ThisTargets.Contains(vr.VariableName))
                    {
                        var p = new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), vr.VariableName);
                        CodeDomVisitor.ReplaceTarget(ctx, p);
                        return;
                        //args.Cancel = true;
                    }
                    else if (scope.TypeTargets.TryGetValue(vr.VariableName, out tref))
                    {
                        var p = new CodePropertyReferenceExpression(new CodeTypeReferenceExpression(tref), vr.VariableName);
                        CodeDomVisitor.ReplaceTarget(ctx, p);
                        return;
                        //args.Cancel = true;
                    }
                }
                else if (scope.EventNames.Contains(vr.VariableName))
                {
                    CodeTypeReference tref;
                    // find out where it belongs.
                    if (scope.ThisTargets.Contains(vr.VariableName))
                    {
                        var e = new CodeEventReferenceExpression(new CodeThisReferenceExpression(), vr.VariableName);
                        CodeDomVisitor.ReplaceTarget(ctx, e);
                        return;
                        //args.Cancel = true;
                    }
                    else if (scope.TypeTargets.TryGetValue(vr.VariableName, out tref))
                    {
                        var e = new CodeEventReferenceExpression(new CodeTypeReferenceExpression(tref), vr.VariableName);
                        CodeDomVisitor.ReplaceTarget(ctx, e);
                        return;
                        //args.Cancel = true;
                    }
                }
                return;
            }
            return;
        }