void ReDimClauseInternal( #line 3146 "VBNET.ATG" ref Expression expr) { #line 3147 "VBNET.ATG" List<Expression> arguments; bool canBeNormal; bool canBeRedim; string name; while (la.kind == 16 || #line 3150 "VBNET.ATG" la.kind == Tokens.OpenParenthesis && Peek(1).kind == Tokens.Of) { if (la.kind == 16) { lexer.NextToken(); IdentifierOrKeyword( #line 3149 "VBNET.ATG" out name); #line 3149 "VBNET.ATG" expr = new MemberReferenceExpression(expr, name); } else { InvocationExpression( #line 3151 "VBNET.ATG" ref expr); } } Expect(25); NormalOrReDimArgumentList( #line 3154 "VBNET.ATG" out arguments, out canBeNormal, out canBeRedim); Expect(26); #line 3156 "VBNET.ATG" expr = new InvocationExpression(expr, arguments); if (canBeRedim == false || canBeNormal && (la.kind == Tokens.Dot || la.kind == Tokens.OpenParenthesis)) { if (this.Errors.Count == 0) { // don't recurse on parse errors - could result in endless recursion ReDimClauseInternal(ref expr); } } }
public void VisitExpression (MemberReferenceExpression expression, MethodProperties meth) { return; }
public override object VisitMemberReferenceExpression(MemberReferenceExpression fieldReferenceExpression, object data) { if (methodReference) { methodReference = false; return new CodeMethodReferenceExpression((CodeExpression)fieldReferenceExpression.TargetObject.AcceptVisitor(this, data), fieldReferenceExpression.MemberName); } if (IsFieldReferenceExpression(fieldReferenceExpression)) { return new CodeFieldReferenceExpression((CodeExpression)fieldReferenceExpression.TargetObject.AcceptVisitor(this, data), fieldReferenceExpression.MemberName); } else { if (fieldReferenceExpression.TargetObject is MemberReferenceExpression) { if (IsPossibleTypeReference((MemberReferenceExpression)fieldReferenceExpression.TargetObject)) { CodeTypeReferenceExpression typeRef = ConvertToTypeReference((MemberReferenceExpression)fieldReferenceExpression.TargetObject); if (IsField(typeRef.Type.BaseType, typeRef.Type.TypeArguments.Count, fieldReferenceExpression.MemberName)) { return new CodeFieldReferenceExpression(typeRef, fieldReferenceExpression.MemberName); } else { return new CodePropertyReferenceExpression(typeRef, fieldReferenceExpression.MemberName); } } } CodeExpression codeExpression = (CodeExpression)fieldReferenceExpression.TargetObject.AcceptVisitor(this, data); return new CodePropertyReferenceExpression(codeExpression, fieldReferenceExpression.MemberName); } }
void SimpleNonInvocationExpression( #line 1645 "VBNET.ATG" out Expression pexpr) { #line 1647 "VBNET.ATG" Expression expr; TypeReference type = null; string name = String.Empty; pexpr = null; if (StartOf(32)) { switch (la.kind) { case 3: { lexer.NextToken(); #line 1655 "VBNET.ATG" pexpr = new PrimitiveExpression(t.literalValue, t.val) { LiteralFormat = t.literalFormat }; break; } case 4: { lexer.NextToken(); #line 1656 "VBNET.ATG" pexpr = new PrimitiveExpression(t.literalValue, t.val) { LiteralFormat = t.literalFormat }; break; } case 7: { lexer.NextToken(); #line 1657 "VBNET.ATG" pexpr = new PrimitiveExpression(t.literalValue, t.val) { LiteralFormat = t.literalFormat }; break; } case 6: { lexer.NextToken(); #line 1658 "VBNET.ATG" pexpr = new PrimitiveExpression(t.literalValue, t.val) { LiteralFormat = t.literalFormat }; break; } case 5: { lexer.NextToken(); #line 1659 "VBNET.ATG" pexpr = new PrimitiveExpression(t.literalValue, t.val) { LiteralFormat = t.literalFormat }; break; } case 9: { lexer.NextToken(); #line 1660 "VBNET.ATG" pexpr = new PrimitiveExpression(t.literalValue, t.val) { LiteralFormat = t.literalFormat }; break; } case 8: { lexer.NextToken(); #line 1661 "VBNET.ATG" pexpr = new PrimitiveExpression(t.literalValue, t.val) { LiteralFormat = t.literalFormat }; break; } case 202: { lexer.NextToken(); #line 1663 "VBNET.ATG" pexpr = new PrimitiveExpression(true, "true"); break; } case 109: { lexer.NextToken(); #line 1664 "VBNET.ATG" pexpr = new PrimitiveExpression(false, "false"); break; } case 151: { lexer.NextToken(); #line 1665 "VBNET.ATG" pexpr = new PrimitiveExpression(null, "null"); break; } case 25: { lexer.NextToken(); Expr( #line 1666 "VBNET.ATG" out expr); Expect(26); #line 1666 "VBNET.ATG" pexpr = new ParenthesizedExpression(expr); break; } case 2: case 45: case 49: case 51: case 52: case 53: case 54: case 57: case 74: case 85: case 91: case 94: case 103: case 108: case 113: case 120: case 126: case 130: case 133: case 156: case 162: case 169: case 188: case 197: case 198: case 208: case 209: case 215: { Identifier(); #line 1668 "VBNET.ATG" pexpr = new IdentifierExpression(t.val); pexpr.StartLocation = t.Location; pexpr.EndLocation = t.EndLocation; if ( #line 1671 "VBNET.ATG" la.kind == Tokens.OpenParenthesis && Peek(1).kind == Tokens.Of) { lexer.NextToken(); Expect(155); TypeArgumentList( #line 1672 "VBNET.ATG" ((IdentifierExpression)pexpr).TypeArguments); Expect(26); } break; } case 55: case 58: case 69: case 86: case 87: case 96: case 128: case 137: case 154: case 181: case 186: case 187: case 193: case 206: case 207: case 210: { #line 1674 "VBNET.ATG" string val = String.Empty; if (StartOf(11)) { PrimitiveTypeName( #line 1675 "VBNET.ATG" out val); } else if (la.kind == 154) { lexer.NextToken(); #line 1675 "VBNET.ATG" val = "System.Object"; } else SynErr(257); #line 1676 "VBNET.ATG" pexpr = new TypeReferenceExpression(new TypeReference(val, true)); break; } case 139: { lexer.NextToken(); #line 1677 "VBNET.ATG" pexpr = new ThisReferenceExpression(); break; } case 144: case 145: { #line 1678 "VBNET.ATG" Expression retExpr = null; if (la.kind == 144) { lexer.NextToken(); #line 1679 "VBNET.ATG" retExpr = new BaseReferenceExpression(); } else if (la.kind == 145) { lexer.NextToken(); #line 1680 "VBNET.ATG" retExpr = new ClassReferenceExpression(); } else SynErr(258); Expect(16); IdentifierOrKeyword( #line 1682 "VBNET.ATG" out name); #line 1682 "VBNET.ATG" pexpr = new MemberReferenceExpression(retExpr, name); break; } case 117: { lexer.NextToken(); Expect(16); Identifier(); #line 1684 "VBNET.ATG" type = new TypeReference(t.val ?? ""); #line 1686 "VBNET.ATG" type.IsGlobal = true; #line 1687 "VBNET.ATG" pexpr = new TypeReferenceExpression(type); break; } case 148: { ObjectCreateExpression( #line 1688 "VBNET.ATG" out expr); #line 1688 "VBNET.ATG" pexpr = expr; break; } case 81: case 93: case 204: { #line 1690 "VBNET.ATG" CastType castType = CastType.Cast; if (la.kind == 93) { lexer.NextToken(); } else if (la.kind == 81) { lexer.NextToken(); #line 1692 "VBNET.ATG" castType = CastType.Conversion; } else if (la.kind == 204) { lexer.NextToken(); #line 1693 "VBNET.ATG" castType = CastType.TryCast; } else SynErr(259); Expect(25); Expr( #line 1695 "VBNET.ATG" out expr); Expect(12); TypeName( #line 1695 "VBNET.ATG" out type); Expect(26); #line 1696 "VBNET.ATG" pexpr = new CastExpression(type, expr, castType); break; } case 63: case 64: case 65: case 66: case 67: case 68: case 70: case 72: case 73: case 77: case 78: case 79: case 80: case 82: case 83: case 84: { CastTarget( #line 1697 "VBNET.ATG" out type); Expect(25); Expr( #line 1697 "VBNET.ATG" out expr); Expect(26); #line 1697 "VBNET.ATG" pexpr = new CastExpression(type, expr, CastType.PrimitiveConversion); break; } case 44: { lexer.NextToken(); Expr( #line 1698 "VBNET.ATG" out expr); #line 1698 "VBNET.ATG" pexpr = new AddressOfExpression(expr); break; } case 116: { lexer.NextToken(); Expect(25); GetTypeTypeName( #line 1699 "VBNET.ATG" out type); Expect(26); #line 1699 "VBNET.ATG" pexpr = new TypeOfExpression(type); break; } case 205: { lexer.NextToken(); SimpleExpr( #line 1700 "VBNET.ATG" out expr); Expect(131); TypeName( #line 1700 "VBNET.ATG" out type); #line 1700 "VBNET.ATG" pexpr = new TypeOfIsExpression(expr, type); break; } case 122: { ConditionalExpression( #line 1701 "VBNET.ATG" out pexpr); break; } } } else if (la.kind == 16) { lexer.NextToken(); IdentifierOrKeyword( #line 1705 "VBNET.ATG" out name); #line 1705 "VBNET.ATG" pexpr = new MemberReferenceExpression(null, name); } else SynErr(260); }
public sealed override object VisitMemberReferenceExpression(MemberReferenceExpression memberReferenceExpression, object data) { this.BeginVisit(memberReferenceExpression); object result = this.TrackedVisitMemberReferenceExpression(memberReferenceExpression, data); this.EndVisit(memberReferenceExpression); return result; }
public override object VisitMemberReferenceExpression(MemberReferenceExpression fieldReferenceExpression, object data) { if (fieldReferenceExpression.TargetObject.IsNull) { fieldReferenceExpression.TargetObject = replaceWith; return null; } else { return base.VisitMemberReferenceExpression(fieldReferenceExpression, data); } }
public override object VisitTypeReferenceExpression(TypeReferenceExpression typeReferenceExpression, object data) { string[] types = typeReferenceExpression.TypeReference.Type.Split ('.'); if (types == null || types.Length == 0) return null; if (types.Length == 1) { ResolveResult result = resolver.ResolveIdentifier (this, typeReferenceExpression.TypeReference.Type); if (result == null) result = CreateResult (typeReferenceExpression.TypeReference); result.StaticResolve = true; return result; } Expression expr = new IdentifierExpression (types[0]); for (int i = 1; i < types.Length; i++) { if (types[i] != "?") expr = new MemberReferenceExpression (expr, types[i]); } return expr.AcceptVisitor (this, data); }
public override object VisitMemberReferenceExpression (MemberReferenceExpression memberReferenceExpression, object data) { ValueReference vref = (ValueReference) memberReferenceExpression.TargetObject.AcceptVisitor (this, data); ValueReference ch = vref.GetChild (memberReferenceExpression.MemberName, ctx.Options); if (ch == null) throw CreateParseError ("Unknown member: {0}", memberReferenceExpression.MemberName); return ch; }
public override object VisitMemberReferenceExpression(MemberReferenceExpression fieldReferenceExpression, object data) { if (fieldReferenceExpression.TargetObject is ThisReferenceExpression) { string name = fieldReferenceExpression.MemberName; foreach (VariableDeclaration var in fields) { if (var.Name == name) { fieldReferenceExpression.MemberName = prefix + name; break; } } } return base.VisitMemberReferenceExpression(fieldReferenceExpression, data); }
public virtual object VisitMemberReferenceExpression(MemberReferenceExpression memberReferenceExpression, object data) { Debug.Assert((memberReferenceExpression != null)); Debug.Assert((memberReferenceExpression.TargetObject != null)); Debug.Assert((memberReferenceExpression.TypeArguments != null)); nodeStack.Push(memberReferenceExpression.TargetObject); memberReferenceExpression.TargetObject.AcceptVisitor(this, data); memberReferenceExpression.TargetObject = ((Expression)(nodeStack.Pop())); for (int i = 0; i < memberReferenceExpression.TypeArguments.Count; i++) { TypeReference o = memberReferenceExpression.TypeArguments[i]; Debug.Assert(o != null); nodeStack.Push(o); o.AcceptVisitor(this, data); o = (TypeReference)nodeStack.Pop(); if (o == null) memberReferenceExpression.TypeArguments.RemoveAt(i--); else memberReferenceExpression.TypeArguments[i] = o; } return null; }
public virtual object VisitMemberReferenceExpression(MemberReferenceExpression memberReferenceExpression, object data) { throw new global::System.NotImplementedException("MemberReferenceExpression"); }
static CodeTypeReferenceExpression ConvertToTypeReference(MemberReferenceExpression fieldReferenceExpression) { StringBuilder type = new StringBuilder(""); while (fieldReferenceExpression.TargetObject is MemberReferenceExpression) { type.Insert(0,'.'); type.Insert(1,fieldReferenceExpression.MemberName.ToCharArray()); fieldReferenceExpression = (MemberReferenceExpression)fieldReferenceExpression.TargetObject; } type.Insert(0,'.'); type.Insert(1,fieldReferenceExpression.MemberName.ToCharArray()); if (fieldReferenceExpression.TargetObject is IdentifierExpression) { type.Insert(0, ((IdentifierExpression)fieldReferenceExpression.TargetObject).Identifier.ToCharArray()); string oldType = type.ToString(); int idx = oldType.LastIndexOf('.'); while (idx > 0) { if (Type.GetType(type.ToString()) != null) { break; } string stype = type.ToString().Substring(idx + 1); type = new StringBuilder(type.ToString().Substring(0, idx)); type.Append("+"); type.Append(stype); idx = type.ToString().LastIndexOf('.'); } if (Type.GetType(type.ToString()) == null) { type = new StringBuilder(oldType); } return new CodeTypeReferenceExpression(type.ToString()); } else if (fieldReferenceExpression.TargetObject is TypeReferenceExpression) { type.Insert(0, ((TypeReferenceExpression)fieldReferenceExpression.TargetObject).TypeReference.Type); return new CodeTypeReferenceExpression(type.ToString()); } else { return null; } }
bool IsPossibleTypeReference(MemberReferenceExpression fieldReferenceExpression) { while (fieldReferenceExpression.TargetObject is MemberReferenceExpression) { fieldReferenceExpression = (MemberReferenceExpression)fieldReferenceExpression.TargetObject; } IdentifierExpression identifier = fieldReferenceExpression.TargetObject as IdentifierExpression; if (identifier != null) return !IsField(identifier.Identifier) && !IsLocalVariable(identifier.Identifier); TypeReferenceExpression tre = fieldReferenceExpression.TargetObject as TypeReferenceExpression; if (tre != null) return true; return false; }
public override object VisitIdentifierExpression(IdentifierExpression identifierExpression, object data) { if (constantTable == null) { constantTable = CreateDictionary("Constants"); } Expression expr; if (constantTable.TryGetValue(identifierExpression.Identifier, out expr)) { MemberReferenceExpression fre = new MemberReferenceExpression(expr, identifierExpression.Identifier); ReplaceCurrentNode(fre); return base.VisitMemberReferenceExpression(fre, data); } return base.VisitIdentifierExpression(identifierExpression, data); }
public override object VisitMemberReferenceExpression (MemberReferenceExpression memberReferenceExpression, object data) { if (memberReferenceExpression == null) { return null; } ResolveResult result; if (String.IsNullOrEmpty (memberReferenceExpression.MemberName)) { if (memberReferenceExpression.TargetObject is TypeReferenceExpression) { result = CreateResult (((TypeReferenceExpression)memberReferenceExpression.TargetObject).TypeReference); result.StaticResolve = true; return result; } // if (memberReferenceExpression.TargetObject is ThisReferenceExpression) { // result = CreateResult (((TypeReferenceExpression)memberReferenceExpression.TargetObject).TypeReference); // result.StaticResolve = true; // return result; // } // return memberReferenceExpression.TargetObject.AcceptVisitor(this, data); } result = memberReferenceExpression.TargetObject.AcceptVisitor (this, data) as ResolveResult; NamespaceResolveResult namespaceResult = result as NamespaceResolveResult; if (namespaceResult != null) { if (String.IsNullOrEmpty (memberReferenceExpression.MemberName)) return namespaceResult; string fullName = namespaceResult.Namespace + "." + memberReferenceExpression.MemberName; if (resolver.Dom.NamespaceExists (fullName, true)) return new NamespaceResolveResult (fullName); DomReturnType searchType = new DomReturnType (fullName); if (memberReferenceExpression.TypeArguments != null) { foreach (TypeReference typeRef in memberReferenceExpression.TypeArguments) { searchType.AddTypeParameter (NRefactoryResolver.ConvertTypeReference (typeRef)); } } IType type = resolver.Dom.GetType (searchType); if (type != null) { result = CreateResult (this.resolver.Unit, new DomReturnType (type)); result.StaticResolve = true; return result; } return null; } if (result != null && result.ResolvedType != null) { foreach (ResolveResult innerResult in result.ResolveResults) { ResolveResult resolvedResult = ResolveMemberReference (innerResult, memberReferenceExpression); if (resolvedResult != null) return resolvedResult; } } else { if (result != null) MonoDevelop.Core.LoggingService.LogWarning ("Couldn't resolve type " + result); } return null; }
public override object VisitInvocationExpression(InvocationExpression invocationExpression, object data) { IdentifierExpression ident = invocationExpression.TargetObject as IdentifierExpression; if (ident != null) { if ("IIF".Equals(ident.Identifier, StringComparison.InvariantCultureIgnoreCase) && invocationExpression.Arguments.Count == 3) { ConditionalExpression ce = new ConditionalExpression(invocationExpression.Arguments[0], invocationExpression.Arguments[1], invocationExpression.Arguments[2]); ReplaceCurrentNode(new ParenthesizedExpression(ce)); return base.VisitConditionalExpression(ce, data); } if ("IsNothing".Equals(ident.Identifier, StringComparison.InvariantCultureIgnoreCase) && invocationExpression.Arguments.Count == 1) { BinaryOperatorExpression boe = new BinaryOperatorExpression(invocationExpression.Arguments[0], BinaryOperatorType.ReferenceEquality, new PrimitiveExpression(null, "null")); ReplaceCurrentNode(new ParenthesizedExpression(boe)); return base.VisitBinaryOperatorExpression(boe, data); } if (methodTable == null) { methodTable = CreateDictionary("Conversion", "FileSystem", "Financial", "Information", "Interaction", "Strings", "VBMath"); } Expression expr; if (methodTable.TryGetValue(ident.Identifier, out expr)) { MemberReferenceExpression fre = new MemberReferenceExpression(expr, ident.Identifier); invocationExpression.TargetObject = fre; } } return base.VisitInvocationExpression(invocationExpression, data); }
ResolveResult ResolveMemberReference (ResolveResult result, MemberReferenceExpression memberReferenceExpression) { IType type = resolver.Dom.GetType (result.ResolvedType); if (type == null) return null; //Console.WriteLine ("Resolve member: " + memberReferenceExpression.MemberName + " on " + type); List<IMember> member = new List<IMember> (); List<IType> accessibleExtTypes = DomType.GetAccessibleExtensionTypes (resolver.Dom, resolver.Unit); // Inheritance of extension methods is handled in DomType foreach (IMethod method in type.GetExtensionMethods (accessibleExtTypes, memberReferenceExpression.MemberName)) { member.Add (method); } bool includeProtected = true; foreach (IType curType in resolver.Dom.GetInheritanceTree (type)) { if (curType.ClassType == MonoDevelop.Projects.Dom.ClassType.Interface && type.ClassType != MonoDevelop.Projects.Dom.ClassType.Interface) continue; if (curType.IsAccessibleFrom (resolver.Dom, resolver.CallingType, resolver.CallingMember, includeProtected)) { foreach (IMember foundMember in curType.SearchMember (memberReferenceExpression.MemberName, true)) { if (foundMember.IsExplicitDeclaration) continue; if (result is BaseResolveResult && foundMember.IsAbstract) continue; member.Add (foundMember); } } } if (member.Count > 0) { if (member [0] is IMethod) { bool isStatic = result.StaticResolve; List<IMember> nonMethodMembers = new List<IMember> (); List<string> errors = new List<string> (); int typeParameterCount = 0; if (memberReferenceExpression.TypeArguments != null) typeParameterCount = memberReferenceExpression.TypeArguments.Count; for (int i = 0; i < member.Count; i++) { IMethod method = member [i] as IMethod; if (method == null) nonMethodMembers.Add (member [i]); if (!member [i].IsAccessibleFrom (resolver.Dom, type, resolver.CallingMember, includeProtected)) errors.Add ( MonoDevelop.Core.GettextCatalog.GetString ("'{0}' is inaccessible due to its protection level.", ambience.GetString (method, OutputFlags.IncludeParameters | OutputFlags.IncludeGenerics))); if (method != null && !method.IsFinalizer && (method.IsExtension || method.WasExtended)/* && method.IsAccessibleFrom (resolver.Dom, type, resolver.CallingMember, true)*/) { continue; } if ((member [i].IsStatic ^ isStatic) || /* !member[i].IsAccessibleFrom (resolver.Dom, type, resolver.CallingMember, includeProtected) || */ (method != null && (method.IsFinalizer || typeParameterCount > 0 && method.TypeParameters.Count != typeParameterCount))) { member.RemoveAt (i); i--; } } if (member.Count == 0) return null; result = new MethodResolveResult (member); ((MethodResolveResult)result).Type = type; ((MethodResolveResult)result).StaticUsage = isStatic; result.CallingType = resolver.CallingType; result.CallingMember = resolver.CallingMember; result.ResolveErrors.AddRange (errors); result.StaticResolve = isStatic; //result.UnresolvedType = result.ResolvedType = member[0].ReturnType; foreach (TypeReference typeReference in memberReferenceExpression.TypeArguments) { ((MethodResolveResult)result).AddGenericArgument (resolver.ResolveType (NRefactoryResolver.ConvertTypeReference (typeReference))); } ((MethodResolveResult)result).ResolveExtensionMethods (); if (nonMethodMembers.Count > 0) { MemberResolveResult baseResult = (MemberResolveResult)CreateResult (nonMethodMembers [0].DeclaringType.CompilationUnit, nonMethodMembers [0].ReturnType); baseResult.ResolvedMember = nonMethodMembers [0]; return new CombinedMethodResolveResult (baseResult, (MethodResolveResult)result); } //System.Console.WriteLine(result + "/" + result.ResolvedType); return result; } if (member [0] is IType) { result = CreateResult (member [0].FullName); result.StaticResolve = true; } else { result = CreateResult (member [0].DeclaringType.CompilationUnit, member [0].ReturnType); ((MemberResolveResult)result).ResolvedMember = member [0]; } if (!member [0].IsAccessibleFrom (resolver.Dom, type, resolver.CallingMember, includeProtected)) result.ResolveErrors.Add (string.Format (MonoDevelop.Core.GettextCatalog.GetString ("'{0}' is inaccessible due to it's protection level."), ambience.GetString (member [0], OutputFlags.IncludeParameters | OutputFlags.IncludeGenerics))); return result; } return new UnresolvedMemberResolveResult (result, memberReferenceExpression.MemberName) { CallingType = resolver.CallingType, CallingMember = resolver.CallingMember }; }
public virtual object TrackedVisitMemberReferenceExpression(MemberReferenceExpression memberReferenceExpression, object data) { return base.VisitMemberReferenceExpression(memberReferenceExpression, data); }
private static string ExtractCalleeFullName(MemberReferenceExpression expression, MethodProperties meth) { if(expression.TargetObject is MemberReferenceExpression) { return ExtractCalleeFullName((MemberReferenceExpression)(expression.TargetObject), meth)+"."+expression.MemberName; } if(expression.TargetObject is IdentifierExpression) { return ((IdentifierExpression)(expression.TargetObject)).Identifier+"."+expression.MemberName; } return ""; }
void MemberAccess( #line 2009 "Frames/cs.ATG" out Expression expr, Expression target) { #line 2010 "Frames/cs.ATG" List<TypeReference> typeList; #line 2012 "Frames/cs.ATG" if (ShouldConvertTargetExpressionToTypeReference(target)) { TypeReference type = GetTypeReferenceFromExpression(target); if (type != null) { target = new TypeReferenceExpression(type) { StartLocation = t.Location, EndLocation = t.EndLocation }; } } Expect(15); Identifier(); #line 2021 "Frames/cs.ATG" expr = new MemberReferenceExpression(target, t.val); expr.StartLocation = t.Location; expr.EndLocation = t.EndLocation; if ( #line 2022 "Frames/cs.ATG" IsGenericInSimpleNameOrMemberAccess()) { TypeArgumentList( #line 2023 "Frames/cs.ATG" out typeList, false); #line 2024 "Frames/cs.ATG" ((MemberReferenceExpression)expr).TypeArguments = typeList; } }
void SimpleExpr( #line 1630 "VBNET.ATG" out Expression pexpr) { #line 1631 "VBNET.ATG" string name; SimpleNonInvocationExpression( #line 1633 "VBNET.ATG" out pexpr); while (la.kind == 16 || la.kind == 17 || la.kind == 25) { if (la.kind == 16) { lexer.NextToken(); IdentifierOrKeyword( #line 1635 "VBNET.ATG" out name); #line 1636 "VBNET.ATG" pexpr = new MemberReferenceExpression(pexpr, name); if ( #line 1637 "VBNET.ATG" la.kind == Tokens.OpenParenthesis && Peek(1).kind == Tokens.Of) { lexer.NextToken(); Expect(155); TypeArgumentList( #line 1638 "VBNET.ATG" ((MemberReferenceExpression)pexpr).TypeArguments); Expect(26); } } else if (la.kind == 17) { lexer.NextToken(); IdentifierOrKeyword( #line 1640 "VBNET.ATG" out name); #line 1640 "VBNET.ATG" pexpr = new BinaryOperatorExpression(pexpr, BinaryOperatorType.DictionaryAccess, new PrimitiveExpression(name, name)); } else { InvocationExpression( #line 1641 "VBNET.ATG" ref pexpr); } } }
public virtual object VisitMemberReferenceExpression(MemberReferenceExpression memberReferenceExpression, object data) { Debug.Assert((memberReferenceExpression != null)); Debug.Assert((memberReferenceExpression.TargetObject != null)); Debug.Assert((memberReferenceExpression.TypeArguments != null)); memberReferenceExpression.TargetObject.AcceptVisitor(this, data); foreach (TypeReference o in memberReferenceExpression.TypeArguments) { Debug.Assert(o != null); o.AcceptVisitor(this, data); } return null; }
bool IsFieldReferenceExpression(MemberReferenceExpression fieldReferenceExpression) { if (fieldReferenceExpression.TargetObject is ThisReferenceExpression || fieldReferenceExpression.TargetObject is BaseReferenceExpression) { //field detection for fields\props inherited from base classes return IsField(fieldReferenceExpression.MemberName); } return false; }