public override object TrackedVisitIdentifierExpression(IdentifierExpression identifierExpression, object data)
{
TypeDeclaration typeDeclaration = (TypeDeclaration) AstUtil.GetParentOfType(identifierExpression, typeof(TypeDeclaration));
if (typeDeclaration != null && typeDeclaration.Parent is TypeDeclaration && !IsInvocation(identifierExpression))
{
IList parentFields = AstUtil.GetChildrenWithType(typeDeclaration.Parent, typeof(FieldDeclaration));
IList innerFields = AstUtil.GetChildrenWithType(typeDeclaration, typeof(FieldDeclaration));
FieldDeclaration field = new FieldDeclaration(null);
field.Fields.Add(new VariableDeclaration(identifierExpression.Identifier));
if (!ContainsField(innerFields, field, false) &&
!IdentifierDeclaredInParameter(identifierExpression) &&
ContainsField(parentFields, field, false))
{
string parentTypeName = ((TypeDeclaration) typeDeclaration.Parent).Name;
AddInstanceField(typeDeclaration, parentTypeName);
IdentifierExpression ins = new IdentifierExpression(parentTypeName);
FieldReferenceExpression fieldReferenceExpression = new FieldReferenceExpression(ins, identifierExpression.Identifier);
fieldReferenceExpression.Parent = identifierExpression.Parent;
ReplaceCurrentNode(fieldReferenceExpression);
}
}
return base.TrackedVisitIdentifierExpression(identifierExpression, data);
}
//, AstExpression expression)
public static InvocationExpression add_Invocation(this BlockStatement blockStatement, string typeName, string methodName, params object[] parameters)
{
if (methodName.valid().isFalse())
return null;
Expression memberExpression = null;
if (typeName.valid())
memberExpression = new MemberReferenceExpression(new IdentifierExpression(typeName), methodName);
else
memberExpression = new IdentifierExpression(methodName);
var memberReference = new InvocationExpression(memberExpression);
if (parameters != null)
{
var arguments = new List<Expression>();
foreach (var parameter in parameters)
if (parameter is Expression)
arguments.add(parameter as Expression);
else
arguments.add(new PrimitiveExpression(parameter, parameter.str()));
memberReference.Arguments = arguments;
}
blockStatement.append(memberReference.expressionStatement());
return memberReference;
}
public override object VisitIdentifierExpression(ICSharpCode.NRefactory.Ast.IdentifierExpression identifierExpression, object data)
{
if (!variables.ContainsKey(identifierExpression.Identifier))
{
ExpressionResult expressionResult = new ExpressionResult(identifierExpression.Identifier);
ResolveResult result = resolver.Resolve(expressionResult, position);
MemberResolveResult mrr = result as MemberResolveResult;
ReferencesMember |= mrr != null && mrr.ResolvedMember != null && !mrr.ResolvedMember.IsStatic;
if (!(result is LocalVariableResolveResult || result is ParameterResolveResult))
{
return(base.VisitIdentifierExpression(identifierExpression, data));
}
// result.ResolvedType == null may be true for namespace names or undeclared variables
if (!result.StaticResolve && !variables.ContainsKey(identifierExpression.Identifier))
{
variables[identifierExpression.Identifier] = new VariableDescriptor(identifierExpression.Identifier)
{
InitialValueUsed = !valueGetsChanged,
Location = new DocumentLocation(MemberLocation.Line + identifierExpression.StartLocation.Line - 1, identifierExpression.StartLocation.Column - 1)
};
variables[identifierExpression.Identifier].ReturnType = result.ResolvedType;
}
if (result != null && !result.StaticResolve && result.ResolvedType != null && !(result is MethodResolveResult) && !(result is NamespaceResolveResult) && !(result is MemberResolveResult))
{
unknownVariables.Add(new KeyValuePair <string, IReturnType> (identifierExpression.Identifier, result.ResolvedType));
}
}
return(base.VisitIdentifierExpression(identifierExpression, data));
}
public override object TrackedVisitIdentifierExpression(IdentifierExpression identifierExpression, object data)
{
if (identifierExpression.Parent is InvocationExpression)
return null;
IList staticTypes = new ArrayList();
staticTypes.Add("java.lang.String");
staticTypes.Add("java.lang.Object");
string type = GetStaticFullName(identifierExpression.Identifier, identifierExpression);
if (type != null)
{
if (!staticTypes.Contains(type) && CodeBase.Mappings.Contains(type))
{
string mappedType = CodeBase.Mappings[type].Target;
TypeReferenceExpression rpe = new TypeReferenceExpression(mappedType);
rpe.Parent = identifierExpression.Parent;
ReplaceCurrentNode(rpe);
}
else if (CodeBase.Types.Contains(type))
{
if (!UsedTypes.Contains(type))
UsedTypes.Add(type);
}
}
return null;
}
//, AstExpression expression)
public static MemberReferenceExpression add_MemberReference(this BlockStatement blockStatement, string memberName, string className)
{
var identifier = new IdentifierExpression(memberName);
var memberReference = new MemberReferenceExpression(identifier, className);
blockStatement.append(memberReference.expressionStatement());
return memberReference;
}
public override object VisitIdentifierExpression(IdentifierExpression identifierExpression, object data)
{
if (nameComparer.Equals(identifierExpression.Identifier, from)) {
identifierExpression.Identifier = to;
}
return base.VisitIdentifierExpression(identifierExpression, data);
}
public override object VisitIdentifierExpression(IdentifierExpression identifierExpression, object data)
{
if (Compare(identifierExpression))
{
identifiers.Add(identifierExpression);
}
return base.VisitIdentifierExpression(identifierExpression, data);
}
public override object VisitIdentifierExpression(ICSharpCode.NRefactory.Ast.IdentifierExpression identifierExpression, object data)
{
if (Compare(identifierExpression))
{
identifiers.Add(identifierExpression);
}
return(base.VisitIdentifierExpression(identifierExpression, data));
}
public override object VisitIdentifierExpression(IdentifierExpression identifierExpression, object data)
{
if (RenameTable.ContainsKey(identifierExpression.Identifier))
{
identifierExpression.Identifier = RenameTable[identifierExpression.Identifier];
}
return null;
}
public override object TrackedVisitIdentifierExpression(IdentifierExpression identifierExpression, object data)
{
if (identifierExpression.Identifier == "System")
{
TypeReferenceExpression typeReferenceExpression = new TypeReferenceExpression("java.lang.System");
ReplaceCurrentNode(typeReferenceExpression);
}
return base.TrackedVisitIdentifierExpression(identifierExpression, data);
}
public override object TrackedVisitIdentifierExpression(IdentifierExpression identifierExpression, object data)
{
if (similarTypes.Contains(identifierExpression.Identifier))
{
string fullTypeName = (string) similarTypes[identifierExpression.Identifier];
TypeReferenceExpression typeReferenceExpression = new TypeReferenceExpression(fullTypeName);
ReplaceCurrentNode(typeReferenceExpression);
}
return base.TrackedVisitIdentifierExpression(identifierExpression, data);
}
public override object TrackedVisitIdentifierExpression(IdentifierExpression identifierExpression, object data)
{
if (data != null && data is string)
{
string identifier = identifierExpression.Identifier;
if (identifier == (string) data)
ReplaceCurrentNode(new IdentifierExpression("value"));
}
return base.TrackedVisitIdentifierExpression(identifierExpression, data);
}
public static int parameterPosition(this ObjectCreateExpression objectCreateExpression, IdentifierExpression identifierExpression)
{
if (objectCreateExpression != null && identifierExpression != null)
for (int i = 0; i < objectCreateExpression.Parameters.Count; i++) // for each arguments
foreach (var iNode in objectCreateExpression.Parameters[i].iNodes<IdentifierExpression>()) // get the IdentifierExpression
if (iNode == identifierExpression) // and compare the values
return i;
"in ObjectCreateExpression.parameterPosition could not find provided IdentifierExpression as a current parameter".error();
return -1;
}
public void IdentifierOnlyInvocation()
{
// InitializeComponents();
IdentifierExpression identifier = new IdentifierExpression("InitializeComponents");
InvocationExpression invocation = new InvocationExpression(identifier, 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);
}
public override object VisitIdentifierExpression(IdentifierExpression identifierExpression, object data)
{
string name = identifierExpression.Identifier;
foreach (VariableDeclaration var in fields) {
if (var.Name == name && !IsLocal(name)) {
identifierExpression.Identifier = prefix + name;
break;
}
}
return base.VisitIdentifierExpression(identifierExpression, data);
}
public override object TrackedVisitIdentifierExpression(IdentifierExpression identifierExpression, object data)
{
if (!IsMethodInvocation(identifierExpression))
{
TypeDeclaration typeDeclaration = (TypeDeclaration) AstUtil.GetParentOfType(identifierExpression, typeof(TypeDeclaration));
string fullName = GetFullName(typeDeclaration);
string key = fullName + "." + identifierExpression.Identifier;
if (CodeBase.References.Contains(key))
identifierExpression.Identifier = (string) CodeBase.References[key];
}
return base.TrackedVisitIdentifierExpression(identifierExpression, data);
}
private InvocationExpression CreateGetClassMethodInvocation(TypeOfExpression typeOfExpression)
{
FieldReferenceExpression argument = new FieldReferenceExpression(typeOfExpression, "AssemblyQualifiedName");
typeOfExpression.Parent = argument;
List<Expression> arguments = new List<Expression>();
arguments.Add(argument);
IdentifierExpression methodIdentifier = new IdentifierExpression("java.lang.Class");
FieldReferenceExpression methodReference = new FieldReferenceExpression(methodIdentifier, "forName");
InvocationExpression invocationExpression = new InvocationExpression(methodReference, arguments);
argument.Parent = invocationExpression;
methodReference.Parent = invocationExpression;
return invocationExpression;
}
public override void GenerateCode(List<AbstractNode> nodes, IList items)
{
ConstructorDeclaration ctor = new ConstructorDeclaration(currentClass.Name, Modifiers.Public, null, null);
ctor.Body = new BlockStatement();
foreach (FieldWrapper w in items) {
string parameterName = codeGen.GetParameterName(w.Field.Name);
ctor.Parameters.Add(new ParameterDeclarationExpression(ConvertType(w.Field.ReturnType),
parameterName));
Expression left = new MemberReferenceExpression(new ThisReferenceExpression(), w.Field.Name);
Expression right = new IdentifierExpression(parameterName);
Expression expr = new AssignmentExpression(left, AssignmentOperatorType.Assign, right);
ctor.Body.AddChild(new ExpressionStatement(expr));
}
nodes.Add(ctor);
}
public override object TrackedVisitIdentifierExpression(IdentifierExpression identifierExpression, object data)
{
if (localVariables.Contains(identifierExpression.Identifier))
{
BlockStatement blockStatement = (BlockStatement) AstUtil.GetParentOfType(identifierExpression, typeof(BlockStatement));
int hashCode = blockStatement.GetHashCode();
if (hashCode != GetScopeHashCode(identifierExpression.Identifier))
{
string renamedVariableName = GetModifiedName(blockStatement, identifierExpression.Identifier);
if (renamedVariableName != null)
identifierExpression.Identifier = renamedVariableName;
}
}
return base.TrackedVisitIdentifierExpression(identifierExpression, data);
}
public override void GenerateCode(List<AbstractNode> nodes, IList items)
{
TypeReference intReference = new TypeReference("System.Int32");
MethodDeclaration method = new MethodDeclaration("GetHashCode", Modifiers.Public | Modifiers.Override, intReference, null, null);
Expression expr = CallGetHashCode(new IdentifierExpression(currentClass.Fields[0].Name));
for (int i = 1; i < currentClass.Fields.Count; i++) {
IdentifierExpression identifier = new IdentifierExpression(currentClass.Fields[i].Name);
expr = new BinaryOperatorExpression(expr, BinaryOperatorType.ExclusiveOr,
CallGetHashCode(identifier));
}
method.Body = new BlockStatement();
method.Body.AddChild(new ReturnStatement(expr));
nodes.Add(method);
TypeReference boolReference = new TypeReference("System.Boolean");
TypeReference objectReference = new TypeReference("System.Object");
method = new MethodDeclaration("Equals", Modifiers.Public | Modifiers.Override, boolReference, null, null);
method.Parameters.Add(new ParameterDeclarationExpression(objectReference, "obj"));
method.Body = new BlockStatement();
TypeReference currentType = ConvertType(currentClass.DefaultReturnType);
expr = new TypeOfIsExpression(new IdentifierExpression("obj"), currentType);
expr = new ParenthesizedExpression(expr);
expr = new UnaryOperatorExpression(expr, UnaryOperatorType.Not);
method.Body.AddChild(new IfElseStatement(expr, new ReturnStatement(new PrimitiveExpression(false, "false"))));
expr = new BinaryOperatorExpression(new ThisReferenceExpression(),
BinaryOperatorType.Equality,
new IdentifierExpression("obj"));
method.Body.AddChild(new IfElseStatement(expr, new ReturnStatement(new PrimitiveExpression(true, "true"))));
VariableDeclaration var = new VariableDeclaration("my" + currentClass.Name,
new CastExpression(currentType, new IdentifierExpression("obj"), CastType.Cast),
currentType);
method.Body.AddChild(new LocalVariableDeclaration(var));
expr = TestEquality(var.Name, currentClass.Fields[0]);
for (int i = 1; i < currentClass.Fields.Count; i++) {
expr = new BinaryOperatorExpression(expr, BinaryOperatorType.LogicalAnd,
TestEquality(var.Name, currentClass.Fields[i]));
}
method.Body.AddChild(new ReturnStatement(expr));
nodes.Add(method);
}
public override object TrackedVisitFieldDeclaration(FieldDeclaration fieldDeclaration, object data)
{
VariableDeclaration field = (VariableDeclaration) fieldDeclaration.Fields[0];
TypeDeclaration typeDeclaration = (TypeDeclaration) fieldDeclaration.Parent;
NodeTypeExistenceVisitor nodeTypeExistenceVisitor = new NodeTypeExistenceVisitor(typeof(ThisReferenceExpression));
NodeTypeExistenceVisitor indexerNodeExistenceVisitor = new NodeTypeExistenceVisitor(typeof(IndexerExpression));
field.Initializer.AcceptVisitor(nodeTypeExistenceVisitor, null);
field.Initializer.AcceptVisitor(indexerNodeExistenceVisitor, null);
if (field.Initializer != null && (field.Initializer is InvocationExpression || IsArrayCreation(fieldDeclaration) || nodeTypeExistenceVisitor.Contains || indexerNodeExistenceVisitor.Contains)
&& !AstUtil.ContainsModifier(fieldDeclaration, Modifiers.Static))
{
IList constructors = AstUtil.GetChildrenWithType(typeDeclaration, typeof(ConstructorDeclaration));
IdentifierExpression left = new IdentifierExpression(field.Name);
Expression right = field.Initializer;
AssignmentExpression assignmentExpression = new AssignmentExpression(left, AssignmentOperatorType.Assign, right);
ExpressionStatement ExpressionStatement = new ExpressionStatement(assignmentExpression);
field.Initializer = null;
ConstructorDeclaration constructorDeclaration = null;
ExpressionStatement.Parent = constructorDeclaration;
foreach (ConstructorDeclaration consDec in constructors)
{
if (!AstUtil.ContainsModifier(consDec, Modifiers.Static))
{
if (consDec.Parameters.Count == 0)
{
constructorDeclaration = consDec;
constructorDeclaration.Body.Children.Add(ExpressionStatement);
constructorDeclaration.Parent = typeDeclaration;
return base.TrackedVisitFieldDeclaration(fieldDeclaration, data);
}
else
{
consDec.ConstructorInitializer = new ConstructorInitializer();
consDec.ConstructorInitializer.ConstructorInitializerType = ConstructorInitializerType.This;
}
}
}
constructorDeclaration = GetConstructor(ExpressionStatement, typeDeclaration);
constructorDeclaration.Parent = typeDeclaration;
return base.TrackedVisitFieldDeclaration(fieldDeclaration, data);
}
return base.TrackedVisitFieldDeclaration(fieldDeclaration, data);
}
public override object TrackedVisitIdentifierExpression(IdentifierExpression identifierExpression, object data)
{
string identifier = ContainsIdentifier(identifierExpression);
if (identifier != null)
{
TypeReferenceExpression replacedIdentifier = new TypeReferenceExpression(identifier);
replacedIdentifier.Parent = identifierExpression.Parent;
ReplaceCurrentNode(replacedIdentifier);
}
else
{
TypeDeclaration typeDeclaration = (TypeDeclaration) AstUtil.GetParentOfType(identifierExpression, typeof(TypeDeclaration));
if (typeDeclaration != null)
CheckThroughParents(typeDeclaration, identifierExpression);
}
return null;
}
private void CreateMethodImplementation(MethodDeclaration equalsMethod)
{
string fieldName = "instancehelper_" + equalsMethod.Name;
IdentifierExpression targetObject = new IdentifierExpression("java.lang.Object");
List<Expression> arguments = new List<Expression>();
arguments.Add(new ThisReferenceExpression());
string parameterName = ((ParameterDeclarationExpression) equalsMethod.Parameters[0]).ParameterName;
IdentifierExpression identifier = new IdentifierExpression(parameterName);
arguments.Add(identifier);
FieldReferenceExpression fieldReferenceExpression = new FieldReferenceExpression(targetObject, fieldName);
InvocationExpression invocationExpression = new InvocationExpression(fieldReferenceExpression, arguments);
ReturnStatement returnStatement = new ReturnStatement(invocationExpression);
BlockStatement block = new BlockStatement();
block.Children.Add(returnStatement);
equalsMethod.Body = block;
}
public override object TrackedVisitArrayCreateExpression(ArrayCreateExpression arrayCreateExpression, object data)
{
string variableName = GetVariableName(arrayCreateExpression);
List<Expression> initializerList = arrayCreateExpression.ArrayInitializer.CreateExpressions;
Expression replacedExpression = arrayCreateExpression;
if (initializerList.Count > 0 && initializerList[0] is CollectionInitializerExpression && data is InsertionBlockData)
{
ArrayCreateExpression replacedArrayCreateExpression = arrayCreateExpression;
replacedArrayCreateExpression.ArrayInitializer = null;
replacedArrayCreateExpression.Arguments.Add(new PrimitiveExpression(initializerList.Count, initializerList.Count.ToString()));
string arrayTypeName = arrayCreateExpression.CreateType.Type + "s";
Position position = Position.After;
if (variableName == null)
{
variableName = arrayTypeName;
position = Position.Before;
}
List<Statement> initStatements = GetArrayInitStatements(replacedArrayCreateExpression, variableName, initializerList);
InsertionBlockData insertionBlockData = (InsertionBlockData) data;
insertionBlockData.Block = (BlockStatement) AstUtil.GetParentOfType(replacedArrayCreateExpression, typeof(BlockStatement));
insertionBlockData.BlockChildIndex = GetBlockChildIndex(replacedArrayCreateExpression, position);
insertionBlockData.Statements = initStatements;
if (variableName == arrayTypeName)
{
IdentifierExpression identifierExpression = new IdentifierExpression(variableName);
replacedExpression = identifierExpression;
VariableDeclaration variableDeclaration = new VariableDeclaration(variableName, arrayCreateExpression);
LocalVariableDeclaration localVariable = new LocalVariableDeclaration(variableDeclaration);
localVariable.TypeReference = arrayCreateExpression.CreateType;
initStatements.Insert(0, localVariable);
}
ReplaceCurrentNode(replacedExpression);
}
return base.TrackedVisitArrayCreateExpression(arrayCreateExpression, data);
}
public override object TrackedVisitIdentifierExpression(IdentifierExpression identifierExpression, object data)
{
if (identifierExpression.StartLocation.X == -1 && identifierExpression.StartLocation.Y == -1)
{
if (identifierExpression.Identifier.Length == 1 && data != null)
{
char ch = identifierExpression.Identifier[0];
int index = ch - 'a';
IList arguments = (IList) data;
if (index > -1 && index < arguments.Count)
{
INode node = (INode) arguments[index];
ReplaceCurrentNode(node);
}
}
else if (identifierExpression.Identifier == "id" && Identifier != null)
ReplaceCurrentNode(Identifier);
}
return null;
}
public override object TrackedVisitIdentifierExpression(IdentifierExpression identifierExpression, object data)
{
if (data != null)
{
string identifier = identifierExpression.Identifier;
DataObject dataObject = (DataObject) data;
if (identifier != "enclosingInstance" && !IsInvocation(identifierExpression) && !dataObject.list.Contains(identifier))
{
string staticFullName = GetStaticFullName(identifier, identifierExpression.Parent);
if (staticFullName == null || !CodeBase.Types.Contains(staticFullName))
{
TypeReference typeReference = GetExpressionType(identifierExpression, dataObject.objectCreation);
if (typeReference != null)
{
if (!unknownFields.Contains(identifier))
unknownFields.Add(identifier, typeReference);
if (!dataObject.list.Contains(identifier))
dataObject.list.Add(identifier, typeReference);
}
}
}
else if (IsInvocation(identifierExpression))
{
TypeDeclaration typeDeclaration = dataObject.anonymous;
if (typeDeclaration != null && typeDeclaration.Name.StartsWith("AnonymousClass"))
{
TypeDeclaration enclosingType = (TypeDeclaration) typeDeclaration.Parent;
IList enclosingMethods = GetAccessibleMethods(enclosingType);
if (ContainsMethod(enclosingMethods, identifier))
{
FieldReferenceExpression fieldReferenceExpression = new FieldReferenceExpression(new IdentifierExpression("enclosingInstance"), identifier);
fieldReferenceExpression.Parent = identifierExpression.Parent;
ReplaceCurrentNode(fieldReferenceExpression);
}
}
}
}
return null;
}
public override object VisitIdentifierExpression(IdentifierExpression identifierExpression, object data)
{
string identifier = identifierExpression.Identifier;
Value arg = context.GetArgumentValue(identifier);
if (arg != null) return arg;
Value local = context.GetLocalVariableValue(identifier);
if (local != null) return local;
if (!context.MethodInfo.IsStatic) {
Value member = context.GetThisValue().GetMemberValue(identifier);
if (member != null) return member;
} else {
MemberInfo memberInfo = context.MethodInfo.DeclaringType.GetMember(identifier);
if (memberInfo != null && memberInfo.IsStatic) {
return Value.GetMemberValue(null, memberInfo, null);
}
}
throw new GetValueException("Identifier \"" + identifier + "\" not found in this context");
}
void SimpleNonInvocationExpression(
//#line 1723 "VBNET.ATG"
out Expression pexpr) {
//#line 1725 "VBNET.ATG"
Expression expr;
CollectionInitializerExpression cie;
TypeReference type = null;
string name = String.Empty;
Location startLocation = la.Location;
pexpr = null;
if (StartOf(34)) {
switch (la.kind) {
case 3: {
lexer.NextToken();
//#line 1735 "VBNET.ATG"
pexpr = new PrimitiveExpression(t.literalValue, t.val) { LiteralFormat = t.literalFormat };
break;
}
case 4: {
lexer.NextToken();
//#line 1736 "VBNET.ATG"
pexpr = new PrimitiveExpression(t.literalValue, t.val) { LiteralFormat = t.literalFormat };
break;
}
case 7: {
lexer.NextToken();
//#line 1737 "VBNET.ATG"
pexpr = new PrimitiveExpression(t.literalValue, t.val) { LiteralFormat = t.literalFormat };
break;
}
case 6: {
lexer.NextToken();
//#line 1738 "VBNET.ATG"
pexpr = new PrimitiveExpression(t.literalValue, t.val) { LiteralFormat = t.literalFormat };
break;
}
case 5: {
lexer.NextToken();
//#line 1739 "VBNET.ATG"
pexpr = new PrimitiveExpression(t.literalValue, t.val) { LiteralFormat = t.literalFormat };
break;
}
case 9: {
lexer.NextToken();
//#line 1740 "VBNET.ATG"
pexpr = new PrimitiveExpression(t.literalValue, t.val) { LiteralFormat = t.literalFormat };
break;
}
case 8: {
lexer.NextToken();
//#line 1741 "VBNET.ATG"
pexpr = new PrimitiveExpression(t.literalValue, t.val) { LiteralFormat = t.literalFormat };
break;
}
case 217: {
lexer.NextToken();
//#line 1743 "VBNET.ATG"
pexpr = new PrimitiveExpression(true, "true");
break;
}
case 122: {
lexer.NextToken();
//#line 1744 "VBNET.ATG"
pexpr = new PrimitiveExpression(false, "false");
break;
}
case 165: {
lexer.NextToken();
//#line 1745 "VBNET.ATG"
pexpr = new PrimitiveExpression(null, "null");
break;
}
case 37: {
lexer.NextToken();
Expr(
//#line 1746 "VBNET.ATG"
out expr);
Expect(38);
//#line 1746 "VBNET.ATG"
pexpr = new ParenthesizedExpression(expr);
break;
}
case 2: case 58: case 62: case 64: case 65: case 66: case 67: case 70: case 87: case 98: case 104: case 107: case 116: case 121: case 126: case 133: case 139: case 143: case 146: case 147: case 170: case 176: case 178: case 184: case 203: case 212: case 213: case 223: case 224: case 230: {
Identifier();
//#line 1748 "VBNET.ATG"
pexpr = new IdentifierExpression(t.val);
pexpr.StartLocation = t.Location; pexpr.EndLocation = t.EndLocation;
if (
//#line 1751 "VBNET.ATG"
la.kind == Tokens.OpenParenthesis && Peek(1).kind == Tokens.Of) {
lexer.NextToken();
Expect(169);
TypeArgumentList(
//#line 1752 "VBNET.ATG"
((IdentifierExpression)pexpr).TypeArguments);
Expect(38);
}
break;
}
case 68: case 71: case 82: case 99: case 100: case 109: case 141: case 151: case 168: case 196: case 201: case 202: case 208: case 221: case 222: case 225: {
//#line 1754 "VBNET.ATG"
string val = String.Empty;
if (StartOf(12)) {
PrimitiveTypeName(
//#line 1755 "VBNET.ATG"
out val);
} else if (la.kind == 168) {
lexer.NextToken();
//#line 1755 "VBNET.ATG"
val = "System.Object";
} else SynErr(280);
//#line 1756 "VBNET.ATG"
pexpr = new TypeReferenceExpression(new TypeReference(val, true));
break;
}
case 153: {
lexer.NextToken();
//#line 1757 "VBNET.ATG"
pexpr = new ThisReferenceExpression();
break;
}
case 158: case 159: {
//#line 1758 "VBNET.ATG"
Expression retExpr = null;
if (la.kind == 158) {
lexer.NextToken();
//#line 1759 "VBNET.ATG"
retExpr = new BaseReferenceExpression() { StartLocation = t.Location, EndLocation = t.EndLocation };
} else if (la.kind == 159) {
lexer.NextToken();
//#line 1760 "VBNET.ATG"
retExpr = new ClassReferenceExpression() { StartLocation = t.Location, EndLocation = t.EndLocation };
} else SynErr(281);
Expect(26);
IdentifierOrKeyword(
//#line 1762 "VBNET.ATG"
out name);
//#line 1762 "VBNET.ATG"
pexpr = new MemberReferenceExpression(retExpr, name) { StartLocation = startLocation, EndLocation = t.EndLocation };
break;
}
case 130: {
lexer.NextToken();
Expect(26);
Identifier();
//#line 1764 "VBNET.ATG"
type = new TypeReference(t.val ?? "");
//#line 1766 "VBNET.ATG"
type.IsGlobal = true;
//#line 1767 "VBNET.ATG"
pexpr = new TypeReferenceExpression(type);
break;
}
case 162: {
ObjectCreateExpression(
//#line 1768 "VBNET.ATG"
out expr);
//#line 1768 "VBNET.ATG"
pexpr = expr;
break;
}
case 35: {
CollectionInitializer(
//#line 1769 "VBNET.ATG"
out cie);
//#line 1769 "VBNET.ATG"
pexpr = cie;
break;
}
case 94: case 106: case 219: {
//#line 1771 "VBNET.ATG"
CastType castType = CastType.Cast;
if (la.kind == 106) {
lexer.NextToken();
} else if (la.kind == 94) {
lexer.NextToken();
//#line 1773 "VBNET.ATG"
castType = CastType.Conversion;
} else if (la.kind == 219) {
lexer.NextToken();
//#line 1774 "VBNET.ATG"
castType = CastType.TryCast;
} else SynErr(282);
Expect(37);
Expr(
//#line 1776 "VBNET.ATG"
out expr);
Expect(22);
TypeName(
//#line 1776 "VBNET.ATG"
out type);
Expect(38);
//#line 1777 "VBNET.ATG"
pexpr = new CastExpression(type, expr, castType);
break;
}
case 76: case 77: case 78: case 79: case 80: case 81: case 83: case 85: case 86: case 90: case 91: case 92: case 93: case 95: case 96: case 97: {
CastTarget(
//#line 1778 "VBNET.ATG"
out type);
Expect(37);
Expr(
//#line 1778 "VBNET.ATG"
out expr);
Expect(38);
//#line 1778 "VBNET.ATG"
pexpr = new CastExpression(type, expr, CastType.PrimitiveConversion);
break;
}
case 57: {
lexer.NextToken();
Expr(
//#line 1779 "VBNET.ATG"
out expr);
//#line 1779 "VBNET.ATG"
pexpr = new AddressOfExpression(expr);
break;
}
case 129: {
lexer.NextToken();
Expect(37);
GetTypeTypeName(
//#line 1780 "VBNET.ATG"
out type);
Expect(38);
//#line 1780 "VBNET.ATG"
pexpr = new TypeOfExpression(type);
break;
}
case 220: {
lexer.NextToken();
SimpleExpr(
//#line 1781 "VBNET.ATG"
out expr);
Expect(144);
TypeName(
//#line 1781 "VBNET.ATG"
out type);
//#line 1781 "VBNET.ATG"
pexpr = new TypeOfIsExpression(expr, type);
break;
}
case 135: {
ConditionalExpression(
//#line 1782 "VBNET.ATG"
out pexpr);
break;
}
case 10: case 16: case 17: case 18: case 19: {
XmlLiteralExpression(
//#line 1783 "VBNET.ATG"
out pexpr);
break;
}
}
} else if (StartOf(35)) {
if (la.kind == 26) {
lexer.NextToken();
if (la.kind == 10) {
lexer.NextToken();
IdentifierOrKeyword(
//#line 1789 "VBNET.ATG"
out name);
Expect(11);
//#line 1790 "VBNET.ATG"
pexpr = new XmlMemberAccessExpression(null, XmlAxisType.Element, name, true) { StartLocation = startLocation, EndLocation = t.EndLocation };
} else if (StartOf(33)) {
IdentifierOrKeyword(
//#line 1791 "VBNET.ATG"
out name);
//#line 1792 "VBNET.ATG"
pexpr = new MemberReferenceExpression(null, name) { StartLocation = startLocation, EndLocation = t.EndLocation };
} else SynErr(283);
} else if (la.kind == 29) {
lexer.NextToken();
IdentifierOrKeyword(
//#line 1794 "VBNET.ATG"
out name);
//#line 1794 "VBNET.ATG"
pexpr = new BinaryOperatorExpression(null, BinaryOperatorType.DictionaryAccess, new PrimitiveExpression(name, name) { StartLocation = t.Location, EndLocation = t.EndLocation });
} else {
//#line 1795 "VBNET.ATG"
XmlAxisType axisType = XmlAxisType.Element; bool isXmlIdentifier = false;
if (la.kind == 27) {
lexer.NextToken();
//#line 1796 "VBNET.ATG"
axisType = XmlAxisType.Descendents;
} else if (la.kind == 28) {
lexer.NextToken();
//#line 1796 "VBNET.ATG"
axisType = XmlAxisType.Attribute;
} else SynErr(284);
if (la.kind == 10) {
lexer.NextToken();
//#line 1797 "VBNET.ATG"
isXmlIdentifier = true;
}
IdentifierOrKeyword(
//#line 1797 "VBNET.ATG"
out name);
if (la.kind == 11) {
lexer.NextToken();
}
//#line 1798 "VBNET.ATG"
pexpr = new XmlMemberAccessExpression(null, axisType, name, isXmlIdentifier);
}
} else SynErr(285);
//#line 1803 "VBNET.ATG"
if (pexpr != null) {
pexpr.StartLocation = startLocation;
pexpr.EndLocation = t.EndLocation;
}
}
public override object TrackedVisitIdentifierExpression(IdentifierExpression identifierExpression, object data)
{
string identifier = identifierExpression.Identifier;
if (this.IsField(identifier))
{
this.Append(string.Concat("self._", identifier));
}
else if ((!IsProperty(identifier) || this.IsMethodParameter(identifier)))
{
this.Append(identifier);
}
else
{
this.Append(string.Concat("self.", identifier));
}
return null;
}
public sealed override object VisitIdentifierExpression(IdentifierExpression identifierExpression, object data) {
this.BeginVisit(identifierExpression);
object result = this.TrackedVisitIdentifierExpression(identifierExpression, data);
this.EndVisit(identifierExpression);
return result;
}
public virtual object TrackedVisitIdentifierExpression(IdentifierExpression identifierExpression, object data) {
return base.VisitIdentifierExpression(identifierExpression, data);
}
public virtual object VisitIdentifierExpression(IdentifierExpression identifierExpression, object data) {
throw new global::System.NotImplementedException("IdentifierExpression");
}
public override object VisitIdentifierExpression(ICSharpCode.NRefactory.Ast.IdentifierExpression identifierExpression, object data)
{
identifiers.Add(identifierExpression.Identifier);
return(null);
}
public override object VisitIdentifierExpression(ICSharpCode.NRefactory.Ast.IdentifierExpression identifierExpression, object data)
{
possibleTypeReferences.Add(new TypeReference(identifierExpression.Identifier));
return(base.VisitIdentifierExpression(identifierExpression, data));
}
