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;
}
