public override object VisitFieldReferenceExpression(FieldReferenceExpression fieldReferenceExpression, object data)
{
if (fieldReferenceExpression == null)
{
return(null);
}
// int. generates a FieldreferenceExpression with TargetObject TypeReferenceExpression and no FieldName
if (fieldReferenceExpression.FieldName == null || fieldReferenceExpression.FieldName == "")
{
if (fieldReferenceExpression.TargetObject is TypeReferenceExpression)
{
return(CreateReturnType(((TypeReferenceExpression)fieldReferenceExpression.TargetObject).TypeReference));
}
}
IReturnType returnType = fieldReferenceExpression.TargetObject.AcceptVisitor(this, data) as IReturnType;
if (returnType != null)
{
if (returnType is NamespaceReturnType)
{
string name = returnType.FullyQualifiedName;
string combinedName;
if (name.Length == 0)
{
combinedName = fieldReferenceExpression.FieldName;
}
else
{
combinedName = name + "." + fieldReferenceExpression.FieldName;
}
if (resolver.ProjectContent.NamespaceExists(combinedName))
{
return(new NamespaceReturnType(combinedName));
}
IClass c = resolver.GetClass(combinedName);
if (c != null)
{
return(c.DefaultReturnType);
}
if (resolver.LanguageProperties.ImportModules)
{
// go through the members of the modules
foreach (object o in resolver.ProjectContent.GetNamespaceContents(name))
{
IMember member = o as IMember;
if (member != null && resolver.IsSameName(member.Name, fieldReferenceExpression.FieldName))
{
return(member.ReturnType);
}
}
}
return(null);
}
return(resolver.SearchMember(returnType, fieldReferenceExpression.FieldName));
}
return(null);
}
public override ICodeNode VisitFieldReferenceExpression(FieldReferenceExpression node)
{
V_1 = node.get_Field().Resolve();
if (V_1 == null || !this.fieldToReplacingExpressionMap.TryGetValue(V_1, out V_0))
{
return(this.VisitFieldReferenceExpression(node));
}
return(V_0.CloneExpressionOnlyAndAttachInstructions(node.get_UnderlyingSameMethodInstructions()));
}
public override ICodeNode VisitFieldReferenceExpression(FieldReferenceExpression node)
{
V_0 = this.VisitFieldReferenceExpression(node);
if (V_0.get_CodeNodeType() != 26)
{
return(V_0);
}
return(this.Visit(V_0));
}
public override ICodeNode VisitFieldReferenceExpression(FieldReferenceExpression node)
{
if (this.context.MethodContext.Method.IsConstructor && node.Field.DeclaringType.FullName == this.context.MethodContext.Method.DeclaringType.FullName)
{
return(propertyRecognizer.VisitFieldReferenceExpression(node));
}
return(base.VisitFieldReferenceExpression(node));
}
public bool CheckForAnotherAssignment(FieldDefinition fieldDef, FieldReferenceExpression assignedReference, HashSet <VariableReference> delegateVariableCopies)
{
this.fieldDef = fieldDef;
this.assignedReference = assignedReference;
this.delegateVariableCopies = delegateVariableCopies;
this.foundUsage = false;
this.Visit(this.theBlockStatement);
return(this.foundUsage);
}
/// <summary>
/// Replaces this pointer if there is one in the inlined method.
/// </summary>
/// <param name="node">
/// A <see cref="FieldReferenceExpression"/>
/// </param>
/// <returns>
/// A <see cref="ICodeNode"/>
/// </returns>
public override ICodeNode VisitFieldReferenceExpression(FieldReferenceExpression node)
{
if (thisSubstitution != null && node.Target == null &&
node.Field.DeclaringType == source.Method.DeclaringType)
{
node.Target = thisSubstitution;
}
return(base.VisitFieldReferenceExpression(node));
}
public override object VisitFieldReferenceExpression(FieldReferenceExpression fieldReferenceExpression, object data)
{
IdentifierExpression ie = fieldReferenceExpression.TargetObject as IdentifierExpression;
if (ie != null && ie.Identifier == dummyName)
{
result = fieldReferenceExpression;
}
return(base.VisitFieldReferenceExpression(fieldReferenceExpression, data));
}
public override object TrackedVisitFieldReferenceExpression(FieldReferenceExpression fieldReferenceExpression, object data)
{
string field = fieldReferenceExpression.FieldName;
if (keywords.Contains(field))
{
fieldReferenceExpression.FieldName = "_" + field;
}
return(base.TrackedVisitFieldReferenceExpression(fieldReferenceExpression, data));
}
public void VBStandaloneIntReferenceExpression()
{
// this is propably not what really should be returned for a standalone int
// reference, but it has to stay consistent because NRefactoryResolver depends
// on this trick.
FieldReferenceExpression fre = ParseUtilVBNet.ParseExpression <FieldReferenceExpression>("inTeGer", true);
Assert.AreEqual("", fre.FieldName);
Assert.AreEqual("System.Int32", ((TypeReferenceExpression)fre.TargetObject).TypeReference.SystemType);
}
bool IsFieldReferenceExpression(FieldReferenceExpression fieldReferenceExpression)
{
if (fieldReferenceExpression.TargetObject is ThisReferenceExpression ||
fieldReferenceExpression.TargetObject is BaseReferenceExpression)
{
//field detection for fields\props inherited from base classes
return(IsField(fieldReferenceExpression.FieldName));
}
return(false);
}
public void This()
{
string program = TestUtil.StatementParse(@"this.toString();");
CompilationUnit cu = TestUtil.ParseProgram(program);
InvocationExpression iv = (InvocationExpression)TestUtil.GetStatementNodeOf(cu, 0);
FieldReferenceExpression fieldReference = (FieldReferenceExpression)iv.TargetObject;
string ivIdType = GetType(fieldReference.TargetObject).Type;
Assert.AreEqual("Test", ivIdType);
}
public ICodeNode VisitFieldReferenceExpression(FieldReferenceExpression node)
{
PropertyDefinition property;
if (IsAutoPropertyConstructorInitializerExpression(node.Field, out property))
{
return(new AutoPropertyConstructorInitializerExpression(property, node.Target, node.MappedInstructions));
}
return(node);
}
public override ICodeNode VisitFieldReferenceExpression(FieldReferenceExpression node)
{
ICodeNode result = base.VisitFieldReferenceExpression(node);
if (result.CodeNodeType == CodeNodeType.VariableReferenceExpression)
{
return(Visit(result));
}
return(result);
}
public override void Visit(FieldReferenceExpression node)
{
Type descendingEnumType = ResolveDescendingEnumType(node);
_recorder.Add(
ctx =>
{
ctx.Descend(node.Field.Name);
ctx.PushDescendigFieldEnumType(descendingEnumType);
});
}
public override ICodeNode VisitFieldReferenceExpression(FieldReferenceExpression node)
{
Expression fieldValue;
FieldDefinition theFieldDef = node.Field.Resolve();
if (theFieldDef != null && fieldsToRemove.TryGetValue(theFieldDef, out fieldValue))
{
return(fieldValue.CloneExpressionOnlyAndAttachInstructions(node.UnderlyingSameMethodInstructions));
}
return(base.VisitFieldReferenceExpression(node));
}
public void Helpers_Regex()
{
string program = TestUtil.StatementParse("Helpers.Regex.split(str, delim);");
CompilationUnit cu = TestUtil.ParseProgram(program);
typeReferenceCorrector.TrackedVisitCompilationUnit(cu, null);
InvocationExpression ivc = (InvocationExpression)TestUtil.GetStatementNodeOf(cu, 0);
FieldReferenceExpression invocationTarget = (FieldReferenceExpression)ivc.TargetObject;
Assert.IsTrue(invocationTarget.TargetObject is TypeReferenceExpression);
Assert.AreEqual("Helpers.Regex", ((TypeReferenceExpression)invocationTarget.TargetObject).TypeReference.Type);
}
public void VBNetGenericFieldReferenceExpressionTest()
{
FieldReferenceExpression fre = ParseUtilVBNet.ParseExpression <FieldReferenceExpression>("SomeClass(of string).myField");
Assert.AreEqual("myField", fre.FieldName);
Assert.IsTrue(fre.TargetObject is TypeReferenceExpression);
TypeReference tr = ((TypeReferenceExpression)fre.TargetObject).TypeReference;
Assert.AreEqual("SomeClass", tr.Type);
Assert.AreEqual(1, tr.GenericTypes.Count);
Assert.AreEqual("System.String", tr.GenericTypes[0].SystemType);
}
public void CSharpFullNamespaceGenericFieldReferenceExpressionTest()
{
FieldReferenceExpression fre = ParseUtilCSharp.ParseExpression <FieldReferenceExpression>("Namespace.Subnamespace.SomeClass<string>.myField");
Assert.AreEqual("myField", fre.FieldName);
Assert.IsTrue(fre.TargetObject is TypeReferenceExpression);
TypeReference tr = ((TypeReferenceExpression)fre.TargetObject).TypeReference;
Assert.AreEqual("Namespace.Subnamespace.SomeClass", tr.Type);
Assert.AreEqual(1, tr.GenericTypes.Count);
Assert.AreEqual("System.String", tr.GenericTypes[0].SystemType);
}
public override object VisitFieldReferenceExpression(FieldReferenceExpression fieldReferenceExpression, object data)
{
if (fieldReferenceExpression.TargetObject.IsNull)
{
fieldReferenceExpression.TargetObject = replaceWith;
return(null);
}
else
{
return(base.VisitFieldReferenceExpression(fieldReferenceExpression, data));
}
}
public void Java_Lang_String()
{
string program = TestUtil.StatementParse("java.lang.String.instancehelper_indexOf(str, pre);");
CompilationUnit cu = TestUtil.ParseProgram(program);
typeReferenceCorrector.TrackedVisitCompilationUnit(cu, null);
InvocationExpression ivc = (InvocationExpression)TestUtil.GetStatementNodeOf(cu, 0);
FieldReferenceExpression invocationTarget = (FieldReferenceExpression)ivc.TargetObject;
Assert.IsTrue(invocationTarget.TargetObject is TypeReferenceExpression);
Assert.AreEqual("java.lang.String", ((TypeReferenceExpression)invocationTarget.TargetObject).TypeReference.Type);
}
public void ArrayMember()
{
string program = TestUtil.StatementParse("Boolean[] flags; int count; count = flags.length;");
CompilationUnit cu = TestUtil.ParseProgram(program);
AssignmentExpression assign = (AssignmentExpression)TestUtil.GetStatementNodeOf(cu, 2);
FieldReferenceExpression fieldReference = (FieldReferenceExpression)assign.Right;
TypeReference arrayFieldType = GetType(fieldReference);
Assert.IsNotNull(arrayFieldType);
Assert.AreEqual("int", arrayFieldType.Type);
}
public override object Visit(InvocationExpression invocationExpression, object data)
{
if (invocationExpression.TargetObject is FieldReferenceExpression)
{
FieldReferenceExpression field = (FieldReferenceExpression)invocationExpression.TargetObject;
IReturnType type = field.TargetObject.AcceptVisitor(this, data) as IReturnType;
ArrayList methods = resolver.SearchMethod(type, field.FieldName);
resolver.ShowStatic = false;
if (methods.Count <= 0)
{
return(null);
}
// TODO: Find the right method
return(((IMethod)methods[0]).ReturnType);
}
else if (invocationExpression.TargetObject is IdentifierExpression)
{
string id = ((IdentifierExpression)invocationExpression.TargetObject).Identifier;
if (resolver.CallingClass == null)
{
return(null);
}
IReturnType type = new ReturnType(resolver.CallingClass.FullyQualifiedName);
ArrayList methods = resolver.SearchMethod(type, id);
resolver.ShowStatic = false;
if (methods.Count <= 0)
{
return(null);
}
// TODO: Find the right method
return(((IMethod)methods[0]).ReturnType);
}
// invocationExpression is delegate call
IReturnType t = invocationExpression.AcceptChildren(this, data) as IReturnType;
if (t == null)
{
return(null);
}
IClass c = resolver.SearchType(t.FullyQualifiedName, resolver.CompilationUnit);
if (c.ClassType == ClassType.Delegate)
{
ArrayList methods = resolver.SearchMethod(t, "invoke");
if (methods.Count <= 0)
{
return(null);
}
return(((IMethod)methods[0]).ReturnType);
}
return(null);
}
public void MethodOnThisReferenceInvocation()
{
// InitializeComponents();
FieldReferenceExpression field = new FieldReferenceExpression(new ThisReferenceExpression(), "InitializeComponents");
InvocationExpression invocation = new InvocationExpression(field, new List <Expression>());
object output = invocation.AcceptVisitor(new CodeDOMVisitor(), null);
Assert.IsTrue(output is CodeMethodInvokeExpression);
CodeMethodInvokeExpression mie = (CodeMethodInvokeExpression)output;
Assert.AreEqual("InitializeComponents", mie.Method.MethodName);
Assert.IsTrue(mie.Method.TargetObject is CodeThisReferenceExpression);
}
/// <summary>
/// Ors flags.
/// </summary>
public static void OrFlag(ref Expression expr, string enumTypeName, string enumFieldName)
{
Expression field = new FieldReferenceExpression(new TypeReferenceExpression(enumTypeName), enumFieldName);
if (expr.IsNull)
{
expr = field;
}
else
{
expr = new BinaryOperatorExpression(expr, BinaryOperatorType.BitwiseOr, field);
}
}
private bool IsMethodInvocation(FieldReferenceExpression fieldReference)
{
if (fieldReference.Parent is InvocationExpression)
{
InvocationExpression invocationExpression = (InvocationExpression)fieldReference.Parent;
if (invocationExpression.TargetObject is FieldReferenceExpression)
{
FieldReferenceExpression invocationReference = (FieldReferenceExpression)invocationExpression.TargetObject;
return(fieldReference.FieldName == invocationReference.FieldName);
}
}
return(false);
}
private void AddProperConstructor(TypeDeclaration typeDeclaration, string instanceFieldName)
{
TypeReference type = new TypeReference(instanceFieldName);
ParameterDeclarationExpression fieldParameter = new ParameterDeclarationExpression(type, instanceFieldName);
FieldReferenceExpression fieldReference = new FieldReferenceExpression(new ThisReferenceExpression(), instanceFieldName);
IdentifierExpression right = new IdentifierExpression(instanceFieldName);
AssignmentExpression assignment = new AssignmentExpression(fieldReference, AssignmentOperatorType.Assign, right);
ExpressionStatement expressionStatement = new ExpressionStatement(assignment);
string fullName = GetFullName(typeDeclaration);
IList constructors = AstUtil.GetChildrenWithType(typeDeclaration, typeof(ConstructorDeclaration));
if (constructors.Count == 0)
{
string name = typeDeclaration.Name;
List <ParameterDeclarationExpression> parameters = new List <ParameterDeclarationExpression>();
parameters.Add(fieldParameter);
ConstructorDeclaration constructorDeclaration = new ConstructorDeclaration(name, Modifiers.Public, parameters, null);
constructorDeclaration.Body = new BlockStatement();
constructorDeclaration.Body.AddChild(expressionStatement);
constructorDeclaration.Parent = typeDeclaration;
CodeBase.References.Add("Cons:" + fullName, null);
typeDeclaration.Children.Add(constructorDeclaration);
}
else
{
foreach (ConstructorDeclaration constructor in constructors)
{
if (!ContainsParameter(constructor.Parameters, fieldParameter))
{
constructor.Parameters.Add(fieldParameter);
if (constructor.ConstructorInitializer != null)
{
ConstructorInitializer ci = constructor.ConstructorInitializer;
if (ci.ConstructorInitializerType == ConstructorInitializerType.This)
{
ci.Arguments.Add(new IdentifierExpression(fieldParameter.ParameterName));
}
}
constructor.Body.Children.Insert(0, expressionStatement);
}
}
if (!CodeBase.References.Contains("Cons:" + fullName))
{
CodeBase.References.Add("Cons:" + fullName, null);
}
}
}
public override object TrackedVisitInvocationExpression(InvocationExpression invocationExpression, object data)
{
if (invocationExpression.TargetObject is IdentifierExpression)
{
TypeDeclaration typeDeclaration = (TypeDeclaration)AstUtil.GetParentOfType(invocationExpression, typeof(TypeDeclaration));
IdentifierExpression methodIdentifier = (IdentifierExpression)invocationExpression.TargetObject;
if (typeDeclaration.Parent is TypeDeclaration)
{
List <ParameterDeclarationExpression> argList = new List <ParameterDeclarationExpression>();
int i = 0;
foreach (Expression argument in invocationExpression.Arguments)
{
TypeReference argumentType = GetExpressionType(argument);
if (argumentType != null)
{
string argType = argumentType.Type;
TypeReference typeReference = new TypeReference(argType);
ParameterDeclarationExpression parameterExpression = new ParameterDeclarationExpression(typeReference, "arg" + i);
parameterExpression.TypeReference.RankSpecifier = new int[0];
i++;
argList.Add(parameterExpression);
}
}
MethodDeclaration argMethod = new MethodDeclaration(methodIdentifier.Identifier, Modifiers.None, null, argList, null);
IList parentMethods = GetAccessibleMethods((TypeDeclaration)typeDeclaration.Parent);
if (Contains(parentMethods, argMethod))
{
int methodIndex = IndexOf(parentMethods, argMethod);
argMethod = (MethodDeclaration)parentMethods[methodIndex];
if (!AstUtil.ContainsModifier(argMethod, Modifiers.Static))
{
string parentTypeName = ((TypeDeclaration)typeDeclaration.Parent).Name;
AddInstanceField(typeDeclaration, parentTypeName);
AddProperConstructor(typeDeclaration, parentTypeName);
FieldReferenceExpression newReference = new FieldReferenceExpression(
new IdentifierExpression(parentTypeName),
((IdentifierExpression)invocationExpression.TargetObject).Identifier);
InvocationExpression newInvication = new InvocationExpression(newReference, invocationExpression.Arguments);
newInvication.Parent = invocationExpression.Parent;
ReplaceCurrentNode(newInvication);
}
}
}
}
return(base.TrackedVisitInvocationExpression(invocationExpression, data));
}
public void PropertyAndMethod()
{
string program = TestUtil.StatementParse("id.Keys.GetEnumerator();");
CompilationUnit cu = TestUtil.ParseProgram(program);
typeReferenceCorrector.TrackedVisitCompilationUnit(cu, null);
InvocationExpression ivc = (InvocationExpression)TestUtil.GetStatementNodeOf(cu, 0);
FieldReferenceExpression fieldReference = (FieldReferenceExpression)ivc.TargetObject;
Expression target = fieldReference.TargetObject;
Assert.IsFalse(target is TypeReferenceExpression);
Assert.IsTrue(target is FieldReferenceExpression);
}
bool IsPossibleTypeReference(FieldReferenceExpression fieldReferenceExpression)
{
while (fieldReferenceExpression.TargetObject is FieldReferenceExpression)
{
fieldReferenceExpression = (FieldReferenceExpression)fieldReferenceExpression.TargetObject;
}
IdentifierExpression identifier = fieldReferenceExpression.TargetObject as IdentifierExpression;
if (identifier != null)
{
return(!IsField(identifier.Identifier) && !IsLocalVariable(identifier.Identifier));
}
return(false);
}
private bool CheckVariableInitialization(ExpressionStatement node)
{
if (!node.IsAssignmentStatement())
{
return(false);
}
BinaryExpression theAssignExpression = node.Expression as BinaryExpression;
if (theAssignExpression.Left.CodeNodeType != CodeNodeType.VariableReferenceExpression)
{
return(false);
}
Expression value = theAssignExpression.Right;
if (value.CodeNodeType == CodeNodeType.CastExpression)
{
value = (value as CastExpression).Expression;
}
if ((value.CodeNodeType != CodeNodeType.LiteralExpression || (value as LiteralExpression).Value != null) &&
(value.CodeNodeType != CodeNodeType.FieldReferenceExpression))
{
return(false);
}
if (value.CodeNodeType == CodeNodeType.FieldReferenceExpression)
{
FieldReferenceExpression fieldReferenceExpression = value as FieldReferenceExpression;
TypeDefinition fieldType = fieldReferenceExpression.ExpressionType.Resolve();
if (fieldType == null || fieldType.BaseType == null || fieldType.BaseType.FullName != "System.MulticastDelegate")
{
return(false);
}
// Slow checks
FieldDefinition fieldDef = fieldReferenceExpression.Field.Resolve();
if ((fieldDef.DeclaringType != this.context.MethodContext.Method.DeclaringType &&
!fieldDef.DeclaringType.IsNestedIn(this.context.MethodContext.Method.DeclaringType)) ||
!fieldDef.DeclaringType.IsCompilerGenerated())
{
return(false);
}
}
initializationsToRemove[(theAssignExpression.Left as VariableReferenceExpression).Variable] = node;
return(true);
}
/// <summary>
/// Ors flags.
/// </summary>
public static void OrFlag(ref Expression expr, string enumTypeName, string enumFieldName)
{
Expression field = new FieldReferenceExpression(new TypeReferenceExpression(enumTypeName), enumFieldName);
if (expr.IsNull)
{
expr = field;
}
else
{
expr = new BinaryOperatorExpression(expr, BinaryOperatorType.BitwiseOr, field);
}
}
private void PrimaryExpr(out Expression pexpr)
{
TypeReference typeReference = null;
List<TypeReference> types = null;
Expression expression;
bool flag = false;
pexpr = null;
if (this.la.kind == 0x70)
{
base.lexer.NextToken();
pexpr = new PrimitiveExpression(true, "true");
}
else if (this.la.kind == 0x47)
{
base.lexer.NextToken();
pexpr = new PrimitiveExpression(false, "false");
}
else if (this.la.kind == 0x59)
{
base.lexer.NextToken();
pexpr = new PrimitiveExpression(null, "null");
}
else if (this.la.kind == 2)
{
base.lexer.NextToken();
pexpr = new PrimitiveExpression(this.t.literalValue, this.t.val);
}
else if ((this.la.kind == 1) && (this.Peek(1).kind == 10))
{
base.Expect(1);
typeReference = new TypeReference(this.t.val);
base.Expect(10);
pexpr = new TypeReferenceExpression(typeReference);
base.Expect(1);
if (typeReference.Type == "global")
{
typeReference.IsGlobal = true;
typeReference.Type = this.t.val ?? "?";
}
else
{
typeReference.Type = typeReference.Type + "." + (this.t.val ?? "?");
}
}
else if (this.la.kind == 1)
{
base.lexer.NextToken();
pexpr = new IdentifierExpression(this.t.val);
}
else if (this.la.kind == 20)
{
base.lexer.NextToken();
this.Expr(out expression);
base.Expect(0x15);
pexpr = new ParenthesizedExpression(expression);
}
else if (!this.StartOf(0x1a))
{
if (this.la.kind == 110)
{
base.lexer.NextToken();
pexpr = new ThisReferenceExpression();
}
else if (this.la.kind == 50)
{
base.lexer.NextToken();
Expression targetObject = new BaseReferenceExpression();
if (this.la.kind == 15)
{
base.lexer.NextToken();
base.Expect(1);
targetObject = new FieldReferenceExpression(targetObject, this.t.val);
}
else if (this.la.kind == 0x12)
{
base.lexer.NextToken();
this.Expr(out expression);
List<Expression> indices = new List<Expression>();
if (expression != null)
{
indices.Add(expression);
}
while (this.la.kind == 14)
{
base.lexer.NextToken();
this.Expr(out expression);
if (expression != null)
{
indices.Add(expression);
}
}
base.Expect(0x13);
targetObject = new IndexerExpression(targetObject, indices);
}
else
{
base.SynErr(0xb3);
}
pexpr = targetObject;
}
else if (this.la.kind == 0x58)
{
base.lexer.NextToken();
this.NonArrayType(out typeReference);
List<Expression> parameters = new List<Expression>();
if (this.la.kind == 20)
{
base.lexer.NextToken();
ObjectCreateExpression expression3 = new ObjectCreateExpression(typeReference, parameters);
if (this.StartOf(0x15))
{
this.Argument(out expression);
if (expression != null)
{
parameters.Add(expression);
}
while (this.la.kind == 14)
{
base.lexer.NextToken();
this.Argument(out expression);
if (expression != null)
{
parameters.Add(expression);
}
}
}
base.Expect(0x15);
pexpr = expression3;
}
else if (this.la.kind == 0x12)
{
base.lexer.NextToken();
flag = true;
ArrayCreateExpression expression4 = new ArrayCreateExpression(typeReference);
pexpr = expression4;
int item = 0;
List<int> list4 = new List<int>();
if ((this.la.kind == 14) || (this.la.kind == 0x13))
{
while (this.la.kind == 14)
{
base.lexer.NextToken();
item++;
}
base.Expect(0x13);
list4.Add(item);
item = 0;
while (this.la.kind == 0x12)
{
base.lexer.NextToken();
while (this.la.kind == 14)
{
base.lexer.NextToken();
item++;
}
base.Expect(0x13);
list4.Add(item);
item = 0;
}
expression4.CreateType.RankSpecifier = list4.ToArray();
this.ArrayInitializer(out expression);
expression4.ArrayInitializer = (ArrayInitializerExpression) expression;
}
else if (this.StartOf(5))
{
this.Expr(out expression);
if (expression != null)
{
parameters.Add(expression);
}
while (this.la.kind == 14)
{
base.lexer.NextToken();
item++;
this.Expr(out expression);
if (expression != null)
{
parameters.Add(expression);
}
}
base.Expect(0x13);
list4.Add(item);
expression4.Arguments = parameters;
for (item = 0; this.la.kind == 0x12; item = 0)
{
base.lexer.NextToken();
while (this.la.kind == 14)
{
base.lexer.NextToken();
item++;
}
base.Expect(0x13);
list4.Add(item);
}
expression4.CreateType.RankSpecifier = list4.ToArray();
if (this.la.kind == 0x10)
{
this.ArrayInitializer(out expression);
expression4.ArrayInitializer = (ArrayInitializerExpression) expression;
}
}
else
{
base.SynErr(180);
}
}
else
{
base.SynErr(0xb5);
}
}
else if (this.la.kind == 0x72)
{
base.lexer.NextToken();
base.Expect(20);
if (this.NotVoidPointer())
{
base.Expect(0x7a);
typeReference = new TypeReference("void");
}
else if (this.StartOf(9))
{
this.TypeWithRestriction(out typeReference, true, true);
}
else
{
base.SynErr(0xb6);
}
base.Expect(0x15);
pexpr = new TypeOfExpression(typeReference);
}
else if ((this.la.kind == 0x3e) && (this.Peek(1).kind == 20))
{
base.Expect(0x3e);
base.Expect(20);
this.Type(out typeReference);
base.Expect(0x15);
pexpr = new DefaultValueExpression(typeReference);
}
else if (this.la.kind == 0x68)
{
base.lexer.NextToken();
base.Expect(20);
this.Type(out typeReference);
base.Expect(0x15);
pexpr = new SizeOfExpression(typeReference);
}
else if (this.la.kind == 0x39)
{
base.lexer.NextToken();
base.Expect(20);
this.Expr(out expression);
base.Expect(0x15);
pexpr = new CheckedExpression(expression);
}
else if (this.la.kind == 0x75)
{
base.lexer.NextToken();
base.Expect(20);
this.Expr(out expression);
base.Expect(0x15);
pexpr = new UncheckedExpression(expression);
}
else if (this.la.kind == 0x3f)
{
base.lexer.NextToken();
this.AnonymousMethodExpr(out expression);
pexpr = expression;
}
else
{
base.SynErr(0xb7);
}
}
else
{
string typeName = null;
switch (this.la.kind)
{
case 0x3d:
base.lexer.NextToken();
typeName = "decimal";
break;
case 0x41:
base.lexer.NextToken();
typeName = "double";
break;
case 0x4a:
base.lexer.NextToken();
typeName = "float";
break;
case 0x33:
base.lexer.NextToken();
typeName = "bool";
break;
case 0x35:
base.lexer.NextToken();
typeName = "byte";
break;
case 0x38:
base.lexer.NextToken();
typeName = "char";
break;
case 0x51:
base.lexer.NextToken();
typeName = "int";
break;
case 0x56:
base.lexer.NextToken();
typeName = "long";
break;
case 90:
base.lexer.NextToken();
typeName = "object";
break;
case 0x65:
base.lexer.NextToken();
typeName = "sbyte";
break;
case 0x67:
base.lexer.NextToken();
typeName = "short";
break;
case 0x6b:
base.lexer.NextToken();
typeName = "string";
break;
case 0x73:
base.lexer.NextToken();
typeName = "uint";
break;
case 0x74:
base.lexer.NextToken();
typeName = "ulong";
break;
case 0x77:
base.lexer.NextToken();
typeName = "ushort";
break;
}
this.t.val = "";
base.Expect(15);
base.Expect(1);
pexpr = new FieldReferenceExpression(new TypeReferenceExpression(typeName), this.t.val);
}
while ((this.StartOf(0x1b) || (this.IsGenericFollowedBy(15) && this.IsTypeReferenceExpression(pexpr))) || this.IsGenericFollowedBy(20))
{
if ((this.la.kind == 0x1f) || (this.la.kind == 0x20))
{
if (this.la.kind == 0x1f)
{
base.lexer.NextToken();
pexpr = new UnaryOperatorExpression(pexpr, UnaryOperatorType.PostIncrement);
}
else if (this.la.kind == 0x20)
{
base.lexer.NextToken();
pexpr = new UnaryOperatorExpression(pexpr, UnaryOperatorType.PostDecrement);
}
else
{
base.SynErr(0xb8);
}
}
else
{
if (this.la.kind == 0x2f)
{
base.lexer.NextToken();
base.Expect(1);
pexpr = new PointerReferenceExpression(pexpr, this.t.val);
continue;
}
if (this.la.kind == 15)
{
base.lexer.NextToken();
base.Expect(1);
pexpr = new FieldReferenceExpression(pexpr, this.t.val);
continue;
}
if (this.IsGenericFollowedBy(15) && this.IsTypeReferenceExpression(pexpr))
{
this.TypeArgumentList(out types, false);
base.Expect(15);
base.Expect(1);
pexpr = new FieldReferenceExpression(this.GetTypeReferenceExpression(pexpr, types), this.t.val);
continue;
}
if (this.la.kind == 20)
{
base.lexer.NextToken();
List<Expression> arguments = new List<Expression>();
if (this.StartOf(0x15))
{
this.Argument(out expression);
if (expression != null)
{
arguments.Add(expression);
}
while (this.la.kind == 14)
{
base.lexer.NextToken();
this.Argument(out expression);
if (expression != null)
{
arguments.Add(expression);
}
}
}
base.Expect(0x15);
pexpr = new InvocationExpression(pexpr, arguments);
continue;
}
if (this.IsGenericFollowedBy(20))
{
this.TypeArgumentList(out types, false);
base.Expect(20);
List<Expression> list6 = new List<Expression>();
if (this.StartOf(0x15))
{
this.Argument(out expression);
if (expression != null)
{
list6.Add(expression);
}
while (this.la.kind == 14)
{
base.lexer.NextToken();
this.Argument(out expression);
if (expression != null)
{
list6.Add(expression);
}
}
}
base.Expect(0x15);
pexpr = new InvocationExpression(pexpr, list6, types);
continue;
}
if (flag)
{
this.Error("element access not allow on array creation");
}
List<Expression> list7 = new List<Expression>();
base.lexer.NextToken();
this.Expr(out expression);
if (expression != null)
{
list7.Add(expression);
}
while (this.la.kind == 14)
{
base.lexer.NextToken();
this.Expr(out expression);
if (expression != null)
{
list7.Add(expression);
}
}
base.Expect(0x13);
pexpr = new IndexerExpression(pexpr, list7);
}
}
}
public override object Visit(FieldReferenceExpression fieldReferenceExpression, object data)
{
if (fieldReferenceExpression == null) {
return null;
}
IReturnType returnType = fieldReferenceExpression.TargetObject.AcceptVisitor(this, data) as IReturnType;
if (returnType != null) {
string name = resolver.SearchNamespace(returnType.FullyQualifiedName, resolver.CompilationUnit);
if (name != null) {
string n = resolver.SearchNamespace(string.Concat(name, ".", fieldReferenceExpression.FieldName), null);
if (n != null) {
return new ReturnType(n);
}
IClass c = resolver.SearchType(string.Concat(name, ".", fieldReferenceExpression.FieldName), resolver.CompilationUnit);
if (c != null) {
resolver.ShowStatic = true;
return new ReturnType(c.FullyQualifiedName);
}
return null;
}
return resolver.SearchMember(returnType, fieldReferenceExpression.FieldName);
}
// Console.WriteLine("returnType of child is null!");
return null;
}
