public static Expression my(ReferenceExpression typeReference)
{
var myReference = new GenericReferenceExpression(typeReference.LexicalInfo);
myReference.Target = AstUtil.CreateReferenceExpression(typeReference.LexicalInfo, "Boo.Lang.Environments.My");
myReference.GenericArguments.Add(TypeReference.Lift(typeReference));
return new MemberReferenceExpression(typeReference.LexicalInfo, myReference, "Instance");
}
override public object Clone()
{
GenericReferenceExpression clone = (GenericReferenceExpression)FormatterServices.GetUninitializedObject(typeof(GenericReferenceExpression));
clone._lexicalInfo = _lexicalInfo;
clone._endSourceLocation = _endSourceLocation;
clone._documentation = _documentation;
clone._entity = _entity;
if (_annotations != null)
{
clone._annotations = (Hashtable)_annotations.Clone();
}
clone._expressionType = _expressionType;
if (null != _target)
{
clone._target = _target.Clone() as Expression;
clone._target.InitializeParent(clone);
}
if (null != _genericArguments)
{
clone._genericArguments = _genericArguments.Clone() as TypeReferenceCollection;
clone._genericArguments.InitializeParent(clone);
}
return(clone);
}
private static Expression LiftGenericType(Type type)
{
var genericRef = new GenericReferenceExpression { Target = ReferenceExpressionFor(type) };
foreach (var arg in type.GetGenericArguments())
genericRef.GenericArguments.Add(TypeReference.Lift(arg));
return genericRef;
}
override public object Clone()
{
GenericReferenceExpression clone = new GenericReferenceExpression();
clone._lexicalInfo = _lexicalInfo;
clone._endSourceLocation = _endSourceLocation;
clone._documentation = _documentation;
clone._isSynthetic = _isSynthetic;
clone._entity = _entity;
if (_annotations != null)
{
clone._annotations = (Hashtable)_annotations.Clone();
}
clone._expressionType = _expressionType;
if (null != _target)
{
clone._target = _target.Clone() as Expression;
clone._target.InitializeParent(clone);
}
if (null != _genericArguments)
{
clone._genericArguments = _genericArguments.Clone() as TypeReferenceCollection;
clone._genericArguments.InitializeParent(clone);
}
return(clone);
}
public static TypeReference Lift(GenericReferenceExpression e)
{
GenericTypeReference typeRef = new GenericTypeReference(e.LexicalInfo);
typeRef.Name = TypeNameFor(e.Target);
typeRef.GenericArguments.ExtendWithClones(e.GenericArguments);
return(typeRef);
}
public override void OnMethodInvocationExpression(MethodInvocationExpression node)
{
if (node is MethodInvocationExpression && node.Target is GenericReferenceExpression)
{
var genericReferenceExpression = (GenericReferenceExpression)node.Target;
if (genericReferenceExpression.Target is MemberReferenceExpression)
{
var memberReferenceExpression = (MemberReferenceExpression)genericReferenceExpression.Target;
if (memberReferenceExpression.Target is MemberReferenceExpression)
{
var memberReferenceExpression2 = (MemberReferenceExpression)memberReferenceExpression.Target;
if (memberReferenceExpression2.Target is MemberReferenceExpression)
{
var memberReferenceExpression3 = (MemberReferenceExpression)memberReferenceExpression2.Target;
if (memberReferenceExpression3.Target is ReferenceExpression)
{
var referenceExpression = (ReferenceExpression)memberReferenceExpression3.Target;
if (referenceExpression.Name == "Boo" && memberReferenceExpression3.Name == "Lang" && memberReferenceExpression2.Name == "Builtins" && memberReferenceExpression.Name == "array" && 1 == ((ICollection)genericReferenceExpression.GenericArguments).Count)
{
TypeReference node2 = genericReferenceExpression.GenericArguments[0];
if (1 == ((ICollection)node.Arguments).Count && node.Arguments[0] is CastExpression)
{
var castExpression = (CastExpression)node.Arguments[0];
Expression target = castExpression.Target;
if (castExpression.Type is SimpleTypeReference)
{
var simpleTypeReference = (SimpleTypeReference)castExpression.Type;
if (simpleTypeReference.Name == "int")
{
var methodInvocationExpression = new MethodInvocationExpression(LexicalInfo.Empty);
var arg_255_0 = methodInvocationExpression;
var genericReferenceExpression2 = new GenericReferenceExpression(LexicalInfo.Empty);
GenericReferenceExpression arg_226_0 = genericReferenceExpression2;
var referenceExpression2 = new ReferenceExpression(LexicalInfo.Empty);
string text = referenceExpression2.Name = "array";
Expression expression = arg_226_0.Target = referenceExpression2;
TypeReferenceCollection typeReferenceCollection = genericReferenceExpression2.GenericArguments = TypeReferenceCollection.FromArray(new TypeReference[]
{
TypeReference.Lift(node2)
});
Expression expression2 = arg_255_0.Target = genericReferenceExpression2;
ExpressionCollection expressionCollection = methodInvocationExpression.Arguments = ExpressionCollection.FromArray(new Expression[]
{
Expression.Lift(target)
});
ReplaceCurrentNode(methodInvocationExpression);
}
}
}
}
}
}
}
}
}
}
B.Expression MakeReferenceExpression(TypeReference typeRef)
{
if (typeRef.IsArrayType)
return new B.TypeofExpression(GetLexicalInfo(typeRef), ConvertTypeReference(typeRef));
B.SimpleTypeReference t = (B.SimpleTypeReference)ConvertTypeReference(typeRef);
B.ReferenceExpression r = MakeReferenceExpression(t.Name);
if (t is B.GenericTypeReference) {
B.GenericReferenceExpression gr = new B.GenericReferenceExpression(GetLexicalInfo(typeRef));
gr.Target = r;
foreach (B.TypeReference tr in ((B.GenericTypeReference)t).GenericArguments) {
gr.GenericArguments.Add(tr);
}
return gr;
} else {
return r;
}
}
B.Expression MakeReferenceExpression(TypeReference typeRef)
{
if (typeRef.IsArrayType)
{
return(new B.TypeofExpression(GetLexicalInfo(typeRef), ConvertTypeReference(typeRef)));
}
B.SimpleTypeReference t = (B.SimpleTypeReference)ConvertTypeReference(typeRef);
B.ReferenceExpression r = MakeReferenceExpression(t.Name);
if (t is B.GenericTypeReference)
{
B.GenericReferenceExpression gr = new B.GenericReferenceExpression(GetLexicalInfo(typeRef));
gr.Target = r;
foreach (B.TypeReference tr in ((B.GenericTypeReference)t).GenericArguments)
{
gr.GenericArguments.Add(tr);
}
return(gr);
}
else
{
return(r);
}
}
public override void OnGenericReferenceExpression(GenericReferenceExpression node)
{
IEntity entity = TypeSystem.TypeSystemServices.GetEntity(node);
switch (entity.EntityType)
{
case EntityType.Type:
{
EmitGetTypeFromHandle(GetSystemType(node));
break;
}
case EntityType.Method:
{
node.Target.Accept(this);
break;
}
default:
{
NotImplemented(node, entity.ToString());
break;
}
}
}
//throws RecognitionException, TokenStreamException
protected Expression slicing_expression()
{
Expression e;
IToken lbrack = null;
IToken oft = null;
IToken begin = null;
IToken lparen = null;
e = null;
SlicingExpression se = null;
MethodInvocationExpression mce = null;
IToken memberName = null;
TypeReference genericArgument = null;
TypeReferenceCollection genericArguments = null;
Expression nameSplice = null;
try { // for error handling
e=atom();
{ // ( ... )*
for (;;)
{
switch ( LA(1) )
{
case OF:
{
{
oft = LT(1);
match(OF);
genericArgument=type_reference();
if (0==inputState.guessing)
{
GenericReferenceExpression gre = new GenericReferenceExpression(ToLexicalInfo(oft));
gre.Target = e;
e = gre;
gre.GenericArguments.Add(genericArgument);
}
}
break;
}
case DOT:
{
{
match(DOT);
{
switch ( LA(1) )
{
case GET:
case INTERNAL:
case PUBLIC:
case PROTECTED:
case REF:
case SET:
case ID:
{
{
memberName=member();
if (0==inputState.guessing)
{
MemberReferenceExpression mre = new MemberReferenceExpression(ToLexicalInfo(memberName));
mre.Target = e;
mre.Name = memberName.getText();
e = mre;
}
}
break;
}
case SPLICE_BEGIN:
{
{
begin = LT(1);
match(SPLICE_BEGIN);
nameSplice=atom();
if (0==inputState.guessing)
{
e = new SpliceMemberReferenceExpression(
ToLexicalInfo(begin),
e,
nameSplice);
}
}
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
}
break;
}
default:
if ((LA(1)==LBRACK) && (tokenSet_56_.member(LA(2))))
{
{
lbrack = LT(1);
match(LBRACK);
{
switch ( LA(1) )
{
case OF:
{
{
match(OF);
if (0==inputState.guessing)
{
GenericReferenceExpression gre = new GenericReferenceExpression(ToLexicalInfo(lbrack));
gre.Target = e;
e = gre;
genericArguments = gre.GenericArguments;
}
type_reference_list(genericArguments);
}
break;
}
case ESEPARATOR:
case CAST:
case CHAR:
case FALSE:
case NOT:
case NULL:
case SELF:
case SUPER:
case TRUE:
case TYPEOF:
case TRIPLE_QUOTED_STRING:
case DOUBLE_QUOTED_STRING:
case SINGLE_QUOTED_STRING:
case ID:
case LBRACK:
case LPAREN:
case SUBTRACT:
case SPLICE_BEGIN:
case COLON:
case LBRACE:
case QQ_BEGIN:
case INCREMENT:
case DECREMENT:
case ONES_COMPLEMENT:
case INT:
case LONG:
case RE_LITERAL:
case DOUBLE:
case FLOAT:
case TIMESPAN:
{
if (0==inputState.guessing)
{
se = new SlicingExpression(ToLexicalInfo(lbrack));
se.Target = e;
e = se;
}
slice(se);
{ // ( ... )*
for (;;)
{
if ((LA(1)==COMMA))
{
match(COMMA);
slice(se);
}
else
{
goto _loop547_breakloop;
}
}
_loop547_breakloop: ;
} // ( ... )*
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
match(RBRACK);
}
}
else if ((LA(1)==LPAREN) && (tokenSet_57_.member(LA(2)))) {
{
lparen = LT(1);
match(LPAREN);
if (0==inputState.guessing)
{
mce = new MethodInvocationExpression(ToLexicalInfo(lparen));
mce.Target = e;
e = mce;
}
{
switch ( LA(1) )
{
case ESEPARATOR:
case CAST:
case CHAR:
case FALSE:
case NOT:
case NULL:
case SELF:
case SUPER:
case TRUE:
case TYPEOF:
case TRIPLE_QUOTED_STRING:
case DOUBLE_QUOTED_STRING:
case SINGLE_QUOTED_STRING:
case ID:
case LBRACK:
case LPAREN:
case SUBTRACT:
case SPLICE_BEGIN:
case MULTIPLY:
case LBRACE:
case QQ_BEGIN:
case INCREMENT:
case DECREMENT:
case ONES_COMPLEMENT:
case INT:
case LONG:
case RE_LITERAL:
case DOUBLE:
case FLOAT:
case TIMESPAN:
{
method_invocation_argument(mce);
{ // ( ... )*
for (;;)
{
if ((LA(1)==COMMA))
{
match(COMMA);
method_invocation_argument(mce);
}
else
{
goto _loop556_breakloop;
}
}
_loop556_breakloop: ;
} // ( ... )*
break;
}
case RPAREN:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
match(RPAREN);
}
}
else
{
goto _loop557_breakloop;
}
break; }
}
_loop557_breakloop: ;
} // ( ... )*
}
catch (RecognitionException ex)
{
if (0 == inputState.guessing)
{
reportError(ex);
recover(ex,tokenSet_58_);
}
else
{
throw ex;
}
}
return e;
}
//throws RecognitionException, TokenStreamException
protected Expression slicing_expression()
{
Expression e;
IToken lbrack = null;
IToken oft = null;
IToken lparen = null;
e = null;
SlicingExpression se = null;
MethodInvocationExpression mce = null;
TypeReference genericArgument = null;
TypeReferenceCollection genericArguments = null;
Expression initializer = null;
try { // for error handling
e=atom();
{ // ( ... )*
for (;;)
{
switch ( LA(1) )
{
case LBRACK:
{
{
lbrack = LT(1);
match(LBRACK);
{
switch ( LA(1) )
{
case OF:
{
{
match(OF);
if (0==inputState.guessing)
{
GenericReferenceExpression gre = new GenericReferenceExpression(SourceLocationFactory.ToLexicalInfo(lbrack));
gre.Target = e;
e = gre;
genericArguments = gre.GenericArguments;
}
type_reference_list(genericArguments);
}
break;
}
case ESEPARATOR:
case CAST:
case CHAR:
case FALSE:
case NOT:
case NULL:
case SELF:
case SUPER:
case TRUE:
case TYPEOF:
case ID:
case TRIPLE_QUOTED_STRING:
case LPAREN:
case DOUBLE_QUOTED_STRING:
case SINGLE_QUOTED_STRING:
case LBRACK:
case SUBTRACT:
case SPLICE_BEGIN:
case DOT:
case COLON:
case MULTIPLY:
case LBRACE:
case QQ_BEGIN:
case LONG:
case INCREMENT:
case DECREMENT:
case ONES_COMPLEMENT:
case INT:
case RE_LITERAL:
case DOUBLE:
case FLOAT:
case TIMESPAN:
{
if (0==inputState.guessing)
{
se = new SlicingExpression(SourceLocationFactory.ToLexicalInfo(lbrack));
se.Target = e;
e = se;
}
slice(se);
{ // ( ... )*
for (;;)
{
if ((LA(1)==COMMA))
{
match(COMMA);
slice(se);
}
else
{
goto _loop525_breakloop;
}
}
_loop525_breakloop: ;
} // ( ... )*
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
match(RBRACK);
}
break;
}
case OF:
{
{
oft = LT(1);
match(OF);
genericArgument=type_reference();
if (0==inputState.guessing)
{
GenericReferenceExpression gre = new GenericReferenceExpression(SourceLocationFactory.ToLexicalInfo(oft));
gre.Target = e;
e = gre;
gre.GenericArguments.Add(genericArgument);
}
}
break;
}
case DOT:
{
{
match(DOT);
{ // ( ... )*
for (;;)
{
if ((LA(1)==NEWLINE))
{
match(NEWLINE);
}
else
{
goto _loop529_breakloop;
}
}
_loop529_breakloop: ;
} // ( ... )*
e=member_reference_expression(e);
}
break;
}
case LPAREN:
{
{
lparen = LT(1);
match(LPAREN);
if (0==inputState.guessing)
{
mce = new MethodInvocationExpression(SourceLocationFactory.ToLexicalInfo(lparen));
mce.Target = e;
e = mce;
}
{
switch ( LA(1) )
{
case ESEPARATOR:
case CAST:
case CHAR:
case FALSE:
case NOT:
case NULL:
case SELF:
case SUPER:
case TRUE:
case TYPEOF:
case ID:
case TRIPLE_QUOTED_STRING:
case LPAREN:
case DOUBLE_QUOTED_STRING:
case SINGLE_QUOTED_STRING:
case LBRACK:
case SUBTRACT:
case SPLICE_BEGIN:
case DOT:
case MULTIPLY:
case LBRACE:
case QQ_BEGIN:
case LONG:
case INCREMENT:
case DECREMENT:
case ONES_COMPLEMENT:
case INT:
case RE_LITERAL:
case DOUBLE:
case FLOAT:
case TIMESPAN:
{
argument(mce);
{ // ( ... )*
for (;;)
{
if ((LA(1)==COMMA))
{
match(COMMA);
argument(mce);
}
else
{
goto _loop533_breakloop;
}
}
_loop533_breakloop: ;
} // ( ... )*
break;
}
case RPAREN:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
match(RPAREN);
{
switch ( LA(1) )
{
case LBRACE:
{
{
bool synPredMatched537 = false;
if (((LA(1)==LBRACE) && (tokenSet_71_.member(LA(2)))))
{
int _m537 = mark();
synPredMatched537 = true;
inputState.guessing++;
try {
{
hash_literal_test();
}
}
catch (RecognitionException)
{
synPredMatched537 = false;
}
rewind(_m537);
inputState.guessing--;
}
if ( synPredMatched537 )
{
initializer=hash_literal();
}
else if ((LA(1)==LBRACE) && (tokenSet_71_.member(LA(2)))) {
initializer=list_initializer();
}
else
{
throw new NoViableAltException(LT(1), getFilename());
}
}
if (0==inputState.guessing)
{
e = new CollectionInitializationExpression(e, initializer);
}
break;
}
case EOF:
case ESEPARATOR:
case AND:
case AS:
case CAST:
case DEF:
case DO:
case ELSE:
case FOR:
case IS:
case ISA:
case IF:
case IN:
case NOT:
case OF:
case OR:
case UNLESS:
case WHILE:
case ID:
case EOS:
case NEWLINE:
case LPAREN:
case RPAREN:
case LBRACK:
case RBRACK:
case ASSIGN:
case SUBTRACT:
case COMMA:
case DOT:
case COLON:
case MULTIPLY:
case EXPONENTIATION:
case BITWISE_OR:
case RBRACE:
case QQ_END:
case INPLACE_BITWISE_OR:
case INPLACE_EXCLUSIVE_OR:
case INPLACE_BITWISE_AND:
case INPLACE_SHIFT_LEFT:
case INPLACE_SHIFT_RIGHT:
case CMP_OPERATOR:
case GREATER_THAN:
case LESS_THAN:
case ADD:
case EXCLUSIVE_OR:
case DIVISION:
case MODULUS:
case BITWISE_AND:
case SHIFT_LEFT:
case SHIFT_RIGHT:
case INCREMENT:
case DECREMENT:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
}
break;
}
default:
{
goto _loop538_breakloop;
}
}
}
_loop538_breakloop: ;
} // ( ... )*
}
catch (RecognitionException ex)
{
if (0 == inputState.guessing)
{
reportError(ex);
recover(ex,tokenSet_72_);
}
else
{
throw ex;
}
}
return e;
}
//throws RecognitionException, TokenStreamException
protected Expression slicing_expression()
{
Expression e;
IToken lbrack = null;
IToken oft = null;
IToken begin = null;
IToken lparen = null;
e = null;
SlicingExpression se = null;
MethodInvocationExpression mce = null;
IToken memberName = null;
TypeReference genericArgument = null;
TypeReferenceCollection genericArguments = null;
Expression nameSplice = null;
Expression initializer = null;
try { // for error handling
e=atom();
{ // ( ... )*
for (;;)
{
if ((LA(1)==LBRACK) && (tokenSet_63_.member(LA(2))))
{
{
lbrack = LT(1);
match(LBRACK);
{
switch ( LA(1) )
{
case OF:
{
{
match(OF);
if (0==inputState.guessing)
{
GenericReferenceExpression gre = new GenericReferenceExpression(ToLexicalInfo(lbrack));
gre.Target = e;
e = gre;
genericArguments = gre.GenericArguments;
}
type_reference_list(genericArguments);
}
break;
}
case ESEPARATOR:
case CAST:
case CHAR:
case FALSE:
case NOT:
case NULL:
case SELF:
case SUPER:
case TRUE:
case TYPEOF:
case ID:
case TRIPLE_QUOTED_STRING:
case DOUBLE_QUOTED_STRING:
case SINGLE_QUOTED_STRING:
case LBRACK:
case LPAREN:
case SPLICE_BEGIN:
case DOT:
case COLON:
case MULTIPLY:
case LBRACE:
case QQ_BEGIN:
case SUBTRACT:
case LONG:
case INCREMENT:
case DECREMENT:
case ONES_COMPLEMENT:
case INT:
case RE_LITERAL:
case DOUBLE:
case FLOAT:
case TIMESPAN:
{
if (0==inputState.guessing)
{
se = new SlicingExpression(ToLexicalInfo(lbrack));
se.Target = e;
e = se;
}
slice(se);
{ // ( ... )*
for (;;)
{
if ((LA(1)==COMMA))
{
match(COMMA);
slice(se);
}
else
{
goto _loop574_breakloop;
}
}
_loop574_breakloop: ;
} // ( ... )*
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
match(RBRACK);
}
}
else if ((LA(1)==OF)) {
{
oft = LT(1);
match(OF);
genericArgument=type_reference();
if (0==inputState.guessing)
{
GenericReferenceExpression gre = new GenericReferenceExpression(ToLexicalInfo(oft));
gre.Target = e;
e = gre;
gre.GenericArguments.Add(genericArgument);
}
}
}
else if ((LA(1)==DOT) && (tokenSet_27_.member(LA(2)))) {
{
match(DOT);
{
switch ( LA(1) )
{
case EVENT:
case GET:
case INTERNAL:
case PUBLIC:
case PROTECTED:
case REF:
case SET:
case ID:
{
{
memberName=member();
if (0==inputState.guessing)
{
e = MemberReferenceForToken(e, memberName);
}
}
break;
}
case SPLICE_BEGIN:
{
{
begin = LT(1);
match(SPLICE_BEGIN);
nameSplice=atom();
if (0==inputState.guessing)
{
e = new SpliceMemberReferenceExpression(
ToLexicalInfo(begin),
e,
nameSplice);
}
}
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
}
}
else if ((LA(1)==LPAREN) && (tokenSet_64_.member(LA(2)))) {
{
lparen = LT(1);
match(LPAREN);
if (0==inputState.guessing)
{
mce = new MethodInvocationExpression(ToLexicalInfo(lparen));
mce.Target = e;
e = mce;
}
{
switch ( LA(1) )
{
case ESEPARATOR:
case CAST:
case CHAR:
case FALSE:
case NOT:
case NULL:
case SELF:
case SUPER:
case TRUE:
case TYPEOF:
case ID:
case TRIPLE_QUOTED_STRING:
case DOUBLE_QUOTED_STRING:
case SINGLE_QUOTED_STRING:
case LBRACK:
case LPAREN:
case SPLICE_BEGIN:
case DOT:
case MULTIPLY:
case LBRACE:
case QQ_BEGIN:
case SUBTRACT:
case LONG:
case INCREMENT:
case DECREMENT:
case ONES_COMPLEMENT:
case INT:
case RE_LITERAL:
case DOUBLE:
case FLOAT:
case TIMESPAN:
{
argument(mce);
{ // ( ... )*
for (;;)
{
if ((LA(1)==COMMA))
{
match(COMMA);
argument(mce);
}
else
{
goto _loop583_breakloop;
}
}
_loop583_breakloop: ;
} // ( ... )*
break;
}
case RPAREN:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
match(RPAREN);
{
if ((LA(1)==LBRACE) && (tokenSet_65_.member(LA(2))))
{
{
bool synPredMatched587 = false;
if (((LA(1)==LBRACE) && (tokenSet_65_.member(LA(2)))))
{
int _m587 = mark();
synPredMatched587 = true;
inputState.guessing++;
try {
{
hash_literal_test();
}
}
catch (RecognitionException)
{
synPredMatched587 = false;
}
rewind(_m587);
inputState.guessing--;
}
if ( synPredMatched587 )
{
initializer=hash_literal();
}
else if ((LA(1)==LBRACE) && (tokenSet_65_.member(LA(2)))) {
initializer=list_initializer();
}
else
{
throw new NoViableAltException(LT(1), getFilename());
}
}
if (0==inputState.guessing)
{
e = new CollectionInitializationExpression(e, initializer);
}
}
else if ((tokenSet_66_.member(LA(1))) && (tokenSet_14_.member(LA(2)))) {
}
else
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
}
else
{
goto _loop588_breakloop;
}
}
_loop588_breakloop: ;
} // ( ... )*
}
catch (RecognitionException ex)
{
if (0 == inputState.guessing)
{
reportError(ex);
recover(ex,tokenSet_67_);
}
else
{
throw ex;
}
}
return e;
}
public override void OnGenericReferenceExpression(GenericReferenceExpression node)
{
Visit(node.Target);
WriteGenericArguments(node.GenericArguments);
}
public Expression member_reference_expression(Expression target)
{
Expression expression = null;
IToken token = null;
expression = target;
try
{
int num = this.LA(1);
if (num == 0x5b)
{
TypeReferenceCollection references;
token = this.LT(1);
this.match(0x5b);
if (base.inputState.guessing == 0)
{
GenericReferenceExpression expression2;
GenericReferenceExpression expression3;
GenericReferenceExpression expression1 = expression2 = new GenericReferenceExpression(ToLexicalInfo(token));
expression2.set_Target(expression);
expression = expression3 = expression2;
references = expression3.get_GenericArguments();
}
this.type_reference_list(references);
this.match(0x5f);
return expression;
}
if (((num != 12) && (num != 20)) && ((num != 0x25) && (num != 0x3b)))
{
throw new NoViableAltException(this.LT(1), this.getFilename());
}
Token token2 = this.member();
if (base.inputState.guessing == 0)
{
MemberReferenceExpression expression4;
MemberReferenceExpression expression7 = expression4 = new MemberReferenceExpression(ToLexicalInfo(token2));
expression4.set_Target(expression);
expression4.set_Name(token2.getText());
expression = expression4;
}
return expression;
}
catch (RecognitionException exception)
{
if (base.inputState.guessing != 0)
{
throw;
}
this.reportError(exception);
this.recover(exception, tokenSet_20_);
return expression;
}
return expression;
}
public ConstructedReturnType ConstructTypeFromGenericReferenceExpression(GenericReferenceExpression node)
{
Stack<Expression> stack = new Stack<Expression>();
Expression expr = node;
while (expr != null) {
stack.Push(expr);
if (expr is MemberReferenceExpression) {
expr = ((MemberReferenceExpression)expr).Target;
} else if (expr is GenericReferenceExpression) {
expr = ((GenericReferenceExpression)expr).Target;
} else {
expr = null;
}
}
StringBuilder name = new StringBuilder();
List<IReturnType> typeArguments = new List<IReturnType>();
while (stack.Count > 0) {
expr = stack.Pop();
if (expr is MemberReferenceExpression) {
name.Append('.');
name.Append(((MemberReferenceExpression)expr).Name);
} else if (expr is GenericReferenceExpression) {
foreach (TypeReference tr in ((GenericReferenceExpression)expr).GenericArguments) {
typeArguments.Add(ConvertVisitor.CreateReturnType(tr, callingClass,
resolver.CallingMember,
resolver.CaretLine,
resolver.CaretColumn,
projectContent));
}
} else if (expr is ReferenceExpression) {
name.Append(((ReferenceExpression)expr).Name);
} else {
LoggingService.Warn("Unknown expression in GenericReferenceExpression: " + expr);
}
}
IReturnType rt = projectContent.SearchType(new SearchTypeRequest(name.ToString(), typeArguments.Count, callingClass,
cu, resolver.CaretLine, resolver.CaretColumn)).Result;
if (rt != null) {
return new ConstructedReturnType(rt, typeArguments);
} else {
return null;
}
}
private static Expression LiftGenericType(Type type)
{
var genericRef = new GenericReferenceExpression { Target = ReferenceExpressionFor(type) };
foreach (var arg in type.GetGenericArguments())
genericRef.GenericArguments.Add(TypeReference.Lift(arg));
return genericRef;
}
public override void LeaveGenericReferenceExpression(GenericReferenceExpression node)
{
if (node.Target.Entity == null || IsError(node.Target.Entity))
{
BindExpressionType(node, TypeSystemServices.ErrorEntity);
return;
}
IEntity entity = NameResolutionService.ResolveGenericReferenceExpression(node, node.Target.Entity);
Bind(node, entity);
if (entity.EntityType == EntityType.Type)
{
BindTypeReferenceExpressionType(node, (IType)entity);
return;
}
if (entity.EntityType == EntityType.Method)
BindExpressionType(node, ((IMethod)entity).Type);
if (!(node.Target is MemberReferenceExpression)) //no self.
node.Target = CodeBuilder.MemberReferenceForEntity(CreateSelfReference(), entity);
}
public IEntity ResolveGenericReferenceExpression(GenericReferenceExpression gre, IEntity definition)
{
ResolveTypeReferenceCollection(gre.GenericArguments);
return _context.TypeSystemServices.GenericsServices.ConstructEntity(definition, gre, gre.GenericArguments);
}
public static TypeReference Lift(GenericReferenceExpression e)
{
GenericTypeReference typeRef = new GenericTypeReference(e.LexicalInfo);
typeRef.Name = TypeNameFor(e.Target);
typeRef.GenericArguments.ExtendWithClones(e.GenericArguments);
return typeRef;
}
override public object Clone()
{
GenericReferenceExpression clone = new GenericReferenceExpression();
clone._lexicalInfo = _lexicalInfo;
clone._endSourceLocation = _endSourceLocation;
clone._documentation = _documentation;
clone._isSynthetic = _isSynthetic;
clone._entity = _entity;
if (_annotations != null) clone._annotations = (Hashtable)_annotations.Clone();
clone._expressionType = _expressionType;
if (null != _target)
{
clone._target = _target.Clone() as Expression;
clone._target.InitializeParent(clone);
}
if (null != _genericArguments)
{
clone._genericArguments = _genericArguments.Clone() as TypeReferenceCollection;
clone._genericArguments.InitializeParent(clone);
}
return clone;
}
//throws RecognitionException, TokenStreamException
protected Expression slicing_expression()
{
Expression e;
IToken lbrack = null;
IToken oft = null;
IToken lparen = null;
e = null;
SlicingExpression se = null;
MethodInvocationExpression mce = null;
TypeReference genericArgument = null;
TypeReferenceCollection genericArguments = null;
try { // for error handling
e=atom();
{ // ( ... )*
for (;;)
{
switch ( LA(1) )
{
case LBRACK:
{
{
lbrack = LT(1);
match(LBRACK);
{
switch ( LA(1) )
{
case OF:
{
{
match(OF);
if (0==inputState.guessing)
{
GenericReferenceExpression gre = new GenericReferenceExpression(SourceLocationFactory.ToLexicalInfo(lbrack));
gre.Target = e;
e = gre;
genericArguments = gre.GenericArguments;
}
type_reference_list(genericArguments);
}
break;
}
case ESEPARATOR:
case CAST:
case CHAR:
case FALSE:
case NOT:
case NULL:
case SELF:
case SUPER:
case TRUE:
case TYPEOF:
case TRIPLE_QUOTED_STRING:
case DOUBLE_QUOTED_STRING:
case SINGLE_QUOTED_STRING:
case ID:
case LBRACK:
case LPAREN:
case SUBTRACT:
case COLON:
case SPLICE_BEGIN:
case LBRACE:
case QQ_BEGIN:
case INCREMENT:
case DECREMENT:
case ONES_COMPLEMENT:
case INT:
case LONG:
case RE_LITERAL:
case DOUBLE:
case FLOAT:
case TIMESPAN:
{
if (0==inputState.guessing)
{
se = new SlicingExpression(SourceLocationFactory.ToLexicalInfo(lbrack));
se.Target = e;
e = se;
}
slice(se);
{ // ( ... )*
for (;;)
{
if ((LA(1)==COMMA))
{
match(COMMA);
slice(se);
}
else
{
goto _loop488_breakloop;
}
}
_loop488_breakloop: ;
} // ( ... )*
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
match(RBRACK);
}
break;
}
case OF:
{
{
oft = LT(1);
match(OF);
genericArgument=type_reference();
if (0==inputState.guessing)
{
GenericReferenceExpression gre = new GenericReferenceExpression(SourceLocationFactory.ToLexicalInfo(oft));
gre.Target = e;
e = gre;
gre.GenericArguments.Add(genericArgument);
}
}
break;
}
case DOT:
{
{
match(DOT);
{ // ( ... )*
for (;;)
{
if ((LA(1)==NEWLINE))
{
match(NEWLINE);
}
else
{
goto _loop500_breakloop;
}
}
_loop500_breakloop: ;
} // ( ... )*
e=member_reference_expression(e);
}
break;
}
case LPAREN:
{
{
lparen = LT(1);
match(LPAREN);
if (0==inputState.guessing)
{
mce = new MethodInvocationExpression(SourceLocationFactory.ToLexicalInfo(lparen));
mce.Target = e;
e = mce;
}
{
switch ( LA(1) )
{
case ESEPARATOR:
case CAST:
case CHAR:
case FALSE:
case NOT:
case NULL:
case SELF:
case SUPER:
case TRUE:
case TYPEOF:
case TRIPLE_QUOTED_STRING:
case DOUBLE_QUOTED_STRING:
case SINGLE_QUOTED_STRING:
case ID:
case LBRACK:
case LPAREN:
case SUBTRACT:
case MULTIPLY:
case SPLICE_BEGIN:
case LBRACE:
case QQ_BEGIN:
case INCREMENT:
case DECREMENT:
case ONES_COMPLEMENT:
case INT:
case LONG:
case RE_LITERAL:
case DOUBLE:
case FLOAT:
case TIMESPAN:
{
method_invocation_argument(mce);
{ // ( ... )*
for (;;)
{
if ((LA(1)==COMMA))
{
match(COMMA);
method_invocation_argument(mce);
}
else
{
goto _loop504_breakloop;
}
}
_loop504_breakloop: ;
} // ( ... )*
break;
}
case RPAREN:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
match(RPAREN);
}
break;
}
default:
bool synPredMatched493 = false;
if (((LA(1)==NEWLINE) && (LA(2)==NEWLINE||LA(2)==DOT)))
{
int _m493 = mark();
synPredMatched493 = true;
inputState.guessing++;
try {
{
{ // ( ... )+
int _cnt492=0;
for (;;)
{
if ((LA(1)==NEWLINE))
{
match(NEWLINE);
}
else
{
if (_cnt492 >= 1) { goto _loop492_breakloop; } else { throw new NoViableAltException(LT(1), getFilename());; }
}
_cnt492++;
}
_loop492_breakloop: ;
} // ( ... )+
match(DOT);
}
}
catch (RecognitionException)
{
synPredMatched493 = false;
}
rewind(_m493);
inputState.guessing--;
}
if ( synPredMatched493 )
{
{
{
{ // ( ... )+
int _cnt497=0;
for (;;)
{
if ((LA(1)==NEWLINE))
{
match(NEWLINE);
}
else
{
if (_cnt497 >= 1) { goto _loop497_breakloop; } else { throw new NoViableAltException(LT(1), getFilename());; }
}
_cnt497++;
}
_loop497_breakloop: ;
} // ( ... )+
match(DOT);
}
e=member_reference_expression(e);
}
}
else
{
goto _loop505_breakloop;
}
break; }
}
_loop505_breakloop: ;
} // ( ... )*
}
catch (RecognitionException ex)
{
if (0 == inputState.guessing)
{
reportError(ex);
recover(ex,tokenSet_58_);
}
else
{
throw ex;
}
}
return e;
}
protected override Statement ExpandImpl(MacroStatement macro)
{
Module module = macro.findModule();
string propname = "";
TypeReference type = new SimpleTypeReference("System.Object");
Expression initializer = null;
if (macro.Arguments[0] is BinaryExpression)
{
var bin = macro.Arguments[0] as BinaryExpression;
initializer = bin.Right;
if (bin.Left is TryCastExpression)
{
var tce = bin.Left as TryCastExpression;
propname = tce.Target.ToCodeString();
type = tce.Type ?? type;
}
//else
//{
// propname = bin.Left.ToCodeString();
//}
}
//else
//{
// propname = macro.Arguments[0].ToCodeString();
//}
var geter = new Method("get_" + propname);
geter.ReturnType = type;
geter.Body = new Block();
if (initializer != null)
{
geter.Body.add(
new IfStatement(
new BinaryExpression(
BinaryOperatorType.Equality,
new NullLiteralExpression(),
new MethodInvocationExpression(
new ReferenceExpression("TryGetParameterNoIgnoreNull"),
new StringLiteralExpression(propname))
),
new Block().add(new MethodInvocationExpression(
new ReferenceExpression("SetProperty"),
new StringLiteralExpression(propname),
initializer ?? new NullLiteralExpression()))
, null
)
);
}
var convertmethod = new GenericReferenceExpression();
convertmethod.Target = new ReferenceExpression("_convert");
convertmethod.GenericArguments.Add(type);
var valuecall = new MethodInvocationExpression(
new ReferenceExpression("TryGetParameterNoIgnoreNull"),
new StringLiteralExpression(propname));
var convertcall = new MethodInvocationExpression(convertmethod,valuecall);
geter.Body.add(new ReturnStatement(new CastExpression(convertcall, type)));
var seter = new Method("set_" + propname);
seter.Body = new Block().add(new MethodInvocationExpression(
new ReferenceExpression("SetProperty"),
new StringLiteralExpression(propname),
new ReferenceExpression("value")));
var prop = new Property(geter, seter, type);
prop.Name = propname;
//try
//{
((TypeDefinition)module.Members[0]).Members.Insert(0, prop);
//}
//catch
//{
// module.Members.Insert(0, prop); //in test env
//}
return null;
}
public Expression Linqify(BlockExpression nodeToConvert, BlockExpression originalNode)
{
//assert on param
//assert one expression statement
if (nodeToConvert.Parameters.Count > 1)
{
throw new NotSupportedException("Only lambdas with zero or one parameter are supported");
}
if (nodeToConvert.Body.Statements.Count != 1 &&
nodeToConvert.Body.FirstStatement as ExpressionStatement == null)
{
throw new NotSupportedException("A lambda expression with a statement body cannot be converted to an expression tree");
}
var closureReturnType = CodeBuilder.CreateTypeReference((originalNode.ExpressionType as ICallableType).GetSignature().ReturnType);
var bodyReturnType = CodeBuilder.CreateTypeReference((originalNode.Body.FirstStatement as ReturnStatement).Expression.ExpressionType);
var hasParameters = nodeToConvert.Parameters.Count == 1;
if (hasParameters)
{
var closureParameter = originalNode.Parameters[0];
var exprP1Init = new DeclarationStatement(new Declaration(nodeToConvert.LexicalInfo, CompilerContext.Current.GetUniqueName(closureParameter.Name)),
new MethodInvocationExpression(ReferenceExpression.Lift("System.Linq.Expressions.Expression.Parameter"),
new TypeofExpression() { Type = closureParameter.Type },
new StringLiteralExpression(closureParameter.Name)));
var exprP1Ref = new ReferenceExpression(exprP1Init.Declaration.Name);
var visitor = new GeneratorExpressionTrees(closureParameter.Name, exprP1Ref, NameResolutionService, CodeBuilder);
visitor.Visit(nodeToConvert.Body);
var constructedExpression = visitor.Expression;
constructedExpression = AddOptionalConvert(closureReturnType, bodyReturnType, constructedExpression);
var exprLambdaGenericArg = new GenericTypeReference("System.Func", closureParameter.Type, closureReturnType);
var exprLambdaCall = new GenericReferenceExpression()
{
Target = ReferenceExpression.Lift("System.Linq.Expressions.Expression.Lambda"),
GenericArguments = { exprLambdaGenericArg }
};
var resultExpr = new MethodInvocationExpression(exprLambdaCall,
constructedExpression,
exprP1Ref);
var linqify = new BlockExpression();
var returnType = new GenericTypeReference("System.Linq.Expressions.Expression", exprLambdaGenericArg);
NameResolutionService.ResolveSimpleTypeReference(returnType);
//this must be set to allow proper type inference
originalNode.ExpressionType = returnType.Entity as IType;
linqify.ReturnType = returnType;
linqify.Body.Add(exprP1Init);
linqify.Body.Add(new ReturnStatement(resultExpr));
return new MethodInvocationExpression(linqify);
}
else
{
var visitor = new GeneratorExpressionTrees(null, null, NameResolutionService, CodeBuilder);
visitor.Visit(nodeToConvert.Body);
var constructedExpression = visitor.Expression;
constructedExpression = AddOptionalConvert(closureReturnType, bodyReturnType, constructedExpression);
var exprLambdaGenericArg = new GenericTypeReference("System.Func", closureReturnType);
var exprLambdaCall = new GenericReferenceExpression()
{
Target = ReferenceExpression.Lift("System.Linq.Expressions.Expression.Lambda"),
GenericArguments = { exprLambdaGenericArg }
};
var resultExpr = new MethodInvocationExpression(exprLambdaCall,
constructedExpression);
var linqify = new BlockExpression();
var returnType = new GenericTypeReference("System.Linq.Expressions.Expression", exprLambdaGenericArg);
NameResolutionService.ResolveSimpleTypeReference(returnType);
//this must be set to allow proper type inference
originalNode.ExpressionType = returnType.Entity as IType;
linqify.ReturnType = returnType;
linqify.Body.Add(new ReturnStatement(resultExpr));
return new MethodInvocationExpression(linqify);
}
}
protected Expression slicing_expression() //throws RecognitionException, TokenStreamException
{
Expression e;
IToken lbrack = null;
IToken oft = null;
IToken begin = null;
IToken lparen = null;
e = null;
SlicingExpression se = null;
MethodInvocationExpression mce = null;
IToken memberName = null;
TypeReference genericArgument = null;
TypeReferenceCollection genericArguments = null;
Expression nameSplice = null;
Expression initializer = null;
UnaryExpression ue = null;
try { // for error handling
e=safe_atom();
{ // ( ... )*
for (;;)
{
if ((LA(1)==LBRACK) && (tokenSet_72_.member(LA(2))))
{
{
lbrack = LT(1);
match(LBRACK);
{
switch ( LA(1) )
{
case OF:
{
{
match(OF);
if (0==inputState.guessing)
{
GenericReferenceExpression gre = new GenericReferenceExpression(ToLexicalInfo(lbrack));
gre.Target = e;
e = gre;
genericArguments = gre.GenericArguments;
}
type_reference_list(genericArguments);
}
break;
}
case ESEPARATOR:
case CAST:
case CHAR:
case FALSE:
case NOT:
case NULL:
case SELF:
case SUPER:
case THEN:
case TRUE:
case TYPEOF:
case TRIPLE_QUOTED_STRING:
case LPAREN:
case DOUBLE_QUOTED_STRING:
case SINGLE_QUOTED_STRING:
case ID:
case MULTIPLY:
case LBRACK:
case SPLICE_BEGIN:
case DOT:
case COLON:
case LBRACE:
case QQ_BEGIN:
case SUBTRACT:
case LONG:
case INCREMENT:
case DECREMENT:
case ONES_COMPLEMENT:
case INT:
case BACKTICK_QUOTED_STRING:
case RE_LITERAL:
case DOUBLE:
case FLOAT:
case TIMESPAN:
{
if (0==inputState.guessing)
{
se = new SlicingExpression(ToLexicalInfo(lbrack));
se.Target = e;
e = se;
}
slice(se);
{ // ( ... )*
for (;;)
{
if ((LA(1)==COMMA))
{
match(COMMA);
slice(se);
}
else
{
goto _loop591_breakloop;
}
}
_loop591_breakloop: ;
} // ( ... )*
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
match(RBRACK);
{
switch ( LA(1) )
{
case NULLABLE_SUFFIX:
{
match(NULLABLE_SUFFIX);
if (0==inputState.guessing)
{
ue = new UnaryExpression(e.LexicalInfo);
ue.Operator = UnaryOperatorType.SafeAccess;
ue.Operand = e;
e = ue;
}
break;
}
case EOF:
case DEDENT:
case ESEPARATOR:
case EOL:
case ASSEMBLY_ATTRIBUTE_BEGIN:
case MODULE_ATTRIBUTE_BEGIN:
case ABSTRACT:
case AND:
case AS:
case BREAK:
case CONTINUE:
case CALLABLE:
case CAST:
case CHAR:
case CLASS:
case CONSTRUCTOR:
case DEF:
case DESTRUCTOR:
case DO:
case ELSE:
case ENUM:
case EVENT:
case FINAL:
case FOR:
case FALSE:
case GOTO:
case INTERFACE:
case INTERNAL:
case IS:
case ISA:
case IF:
case IN:
case NEW:
case NOT:
case NULL:
case OF:
case OR:
case OVERRIDE:
case PARTIAL:
case PUBLIC:
case PROTECTED:
case PRIVATE:
case RAISE:
case RETURN:
case SELF:
case SUPER:
case STATIC:
case STRUCT:
case THEN:
case TRY:
case TRANSIENT:
case TRUE:
case TYPEOF:
case UNLESS:
case VIRTUAL:
case WHILE:
case YIELD:
case TRIPLE_QUOTED_STRING:
case EOS:
case LPAREN:
case RPAREN:
case DOUBLE_QUOTED_STRING:
case SINGLE_QUOTED_STRING:
case ID:
case MULTIPLY:
case LBRACK:
case RBRACK:
case ASSIGN:
case COMMA:
case SPLICE_BEGIN:
case DOT:
case COLON:
case EXPONENTIATION:
case BITWISE_OR:
case LBRACE:
case RBRACE:
case QQ_BEGIN:
case QQ_END:
case INPLACE_BITWISE_OR:
case INPLACE_EXCLUSIVE_OR:
case INPLACE_BITWISE_AND:
case INPLACE_SHIFT_LEFT:
case INPLACE_SHIFT_RIGHT:
case CMP_OPERATOR:
case GREATER_THAN:
case LESS_THAN:
case ADD:
case SUBTRACT:
case EXCLUSIVE_OR:
case DIVISION:
case MODULUS:
case BITWISE_AND:
case SHIFT_LEFT:
case SHIFT_RIGHT:
case LONG:
case INCREMENT:
case DECREMENT:
case ONES_COMPLEMENT:
case INT:
case BACKTICK_QUOTED_STRING:
case RE_LITERAL:
case DOUBLE:
case FLOAT:
case TIMESPAN:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
}
}
else if ((LA(1)==OF)) {
{
oft = LT(1);
match(OF);
genericArgument=type_reference();
if (0==inputState.guessing)
{
GenericReferenceExpression gre = new GenericReferenceExpression(ToLexicalInfo(oft));
gre.Target = e;
e = gre;
gre.GenericArguments.Add(genericArgument);
}
}
}
else if ((LA(1)==DOT) && (tokenSet_33_.member(LA(2)))) {
{
match(DOT);
{
switch ( LA(1) )
{
case EVENT:
case GET:
case INTERNAL:
case PUBLIC:
case PROTECTED:
case REF:
case SET:
case YIELD:
case ID:
{
{
memberName=member();
if (0==inputState.guessing)
{
e = MemberReferenceForToken(e, memberName);
}
}
break;
}
case SPLICE_BEGIN:
{
{
begin = LT(1);
match(SPLICE_BEGIN);
nameSplice=atom();
if (0==inputState.guessing)
{
e = new SpliceMemberReferenceExpression(
ToLexicalInfo(begin),
e,
nameSplice);
}
}
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
switch ( LA(1) )
{
case NULLABLE_SUFFIX:
{
match(NULLABLE_SUFFIX);
if (0==inputState.guessing)
{
ue = new UnaryExpression(e.LexicalInfo);
ue.Operator = UnaryOperatorType.SafeAccess;
ue.Operand = e;
e = ue;
}
break;
}
case EOF:
case DEDENT:
case ESEPARATOR:
case EOL:
case ASSEMBLY_ATTRIBUTE_BEGIN:
case MODULE_ATTRIBUTE_BEGIN:
case ABSTRACT:
case AND:
case AS:
case BREAK:
case CONTINUE:
case CALLABLE:
case CAST:
case CHAR:
case CLASS:
case CONSTRUCTOR:
case DEF:
case DESTRUCTOR:
case DO:
case ELSE:
case ENUM:
case EVENT:
case FINAL:
case FOR:
case FALSE:
case GOTO:
case INTERFACE:
case INTERNAL:
case IS:
case ISA:
case IF:
case IN:
case NEW:
case NOT:
case NULL:
case OF:
case OR:
case OVERRIDE:
case PARTIAL:
case PUBLIC:
case PROTECTED:
case PRIVATE:
case RAISE:
case RETURN:
case SELF:
case SUPER:
case STATIC:
case STRUCT:
case THEN:
case TRY:
case TRANSIENT:
case TRUE:
case TYPEOF:
case UNLESS:
case VIRTUAL:
case WHILE:
case YIELD:
case TRIPLE_QUOTED_STRING:
case EOS:
case LPAREN:
case RPAREN:
case DOUBLE_QUOTED_STRING:
case SINGLE_QUOTED_STRING:
case ID:
case MULTIPLY:
case LBRACK:
case RBRACK:
case ASSIGN:
case COMMA:
case SPLICE_BEGIN:
case DOT:
case COLON:
case EXPONENTIATION:
case BITWISE_OR:
case LBRACE:
case RBRACE:
case QQ_BEGIN:
case QQ_END:
case INPLACE_BITWISE_OR:
case INPLACE_EXCLUSIVE_OR:
case INPLACE_BITWISE_AND:
case INPLACE_SHIFT_LEFT:
case INPLACE_SHIFT_RIGHT:
case CMP_OPERATOR:
case GREATER_THAN:
case LESS_THAN:
case ADD:
case SUBTRACT:
case EXCLUSIVE_OR:
case DIVISION:
case MODULUS:
case BITWISE_AND:
case SHIFT_LEFT:
case SHIFT_RIGHT:
case LONG:
case INCREMENT:
case DECREMENT:
case ONES_COMPLEMENT:
case INT:
case BACKTICK_QUOTED_STRING:
case RE_LITERAL:
case DOUBLE:
case FLOAT:
case TIMESPAN:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
}
}
else if ((LA(1)==LPAREN) && (tokenSet_73_.member(LA(2)))) {
{
lparen = LT(1);
match(LPAREN);
if (0==inputState.guessing)
{
mce = new MethodInvocationExpression(ToLexicalInfo(lparen));
mce.Target = e;
e = mce;
}
{
switch ( LA(1) )
{
case ESEPARATOR:
case CAST:
case CHAR:
case FALSE:
case NOT:
case NULL:
case SELF:
case SUPER:
case THEN:
case TRUE:
case TYPEOF:
case TRIPLE_QUOTED_STRING:
case LPAREN:
case DOUBLE_QUOTED_STRING:
case SINGLE_QUOTED_STRING:
case ID:
case MULTIPLY:
case LBRACK:
case SPLICE_BEGIN:
case DOT:
case LBRACE:
case QQ_BEGIN:
case SUBTRACT:
case LONG:
case INCREMENT:
case DECREMENT:
case ONES_COMPLEMENT:
case INT:
case BACKTICK_QUOTED_STRING:
case RE_LITERAL:
case DOUBLE:
case FLOAT:
case TIMESPAN:
{
argument(mce);
{ // ( ... )*
for (;;)
{
if ((LA(1)==COMMA))
{
match(COMMA);
argument(mce);
}
else
{
goto _loop602_breakloop;
}
}
_loop602_breakloop: ;
} // ( ... )*
break;
}
case RPAREN:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
match(RPAREN);
{
switch ( LA(1) )
{
case NULLABLE_SUFFIX:
{
match(NULLABLE_SUFFIX);
if (0==inputState.guessing)
{
ue = new UnaryExpression(e.LexicalInfo);
ue.Operator = UnaryOperatorType.SafeAccess;
ue.Operand = e;
e = ue;
}
break;
}
case EOF:
case DEDENT:
case ESEPARATOR:
case EOL:
case ASSEMBLY_ATTRIBUTE_BEGIN:
case MODULE_ATTRIBUTE_BEGIN:
case ABSTRACT:
case AND:
case AS:
case BREAK:
case CONTINUE:
case CALLABLE:
case CAST:
case CHAR:
case CLASS:
case CONSTRUCTOR:
case DEF:
case DESTRUCTOR:
case DO:
case ELSE:
case ENUM:
case EVENT:
case FINAL:
case FOR:
case FALSE:
case GOTO:
case INTERFACE:
case INTERNAL:
case IS:
case ISA:
case IF:
case IN:
case NEW:
case NOT:
case NULL:
case OF:
case OR:
case OVERRIDE:
case PARTIAL:
case PUBLIC:
case PROTECTED:
case PRIVATE:
case RAISE:
case RETURN:
case SELF:
case SUPER:
case STATIC:
case STRUCT:
case THEN:
case TRY:
case TRANSIENT:
case TRUE:
case TYPEOF:
case UNLESS:
case VIRTUAL:
case WHILE:
case YIELD:
case TRIPLE_QUOTED_STRING:
case EOS:
case LPAREN:
case RPAREN:
case DOUBLE_QUOTED_STRING:
case SINGLE_QUOTED_STRING:
case ID:
case MULTIPLY:
case LBRACK:
case RBRACK:
case ASSIGN:
case COMMA:
case SPLICE_BEGIN:
case DOT:
case COLON:
case EXPONENTIATION:
case BITWISE_OR:
case LBRACE:
case RBRACE:
case QQ_BEGIN:
case QQ_END:
case INPLACE_BITWISE_OR:
case INPLACE_EXCLUSIVE_OR:
case INPLACE_BITWISE_AND:
case INPLACE_SHIFT_LEFT:
case INPLACE_SHIFT_RIGHT:
case CMP_OPERATOR:
case GREATER_THAN:
case LESS_THAN:
case ADD:
case SUBTRACT:
case EXCLUSIVE_OR:
case DIVISION:
case MODULUS:
case BITWISE_AND:
case SHIFT_LEFT:
case SHIFT_RIGHT:
case LONG:
case INCREMENT:
case DECREMENT:
case ONES_COMPLEMENT:
case INT:
case BACKTICK_QUOTED_STRING:
case RE_LITERAL:
case DOUBLE:
case FLOAT:
case TIMESPAN:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
if ((LA(1)==LBRACE) && (tokenSet_74_.member(LA(2))))
{
{
bool synPredMatched607 = false;
if (((LA(1)==LBRACE) && (tokenSet_74_.member(LA(2)))))
{
int _m607 = mark();
synPredMatched607 = true;
inputState.guessing++;
try {
{
hash_literal_test();
}
}
catch (RecognitionException)
{
synPredMatched607 = false;
}
rewind(_m607);
inputState.guessing--;
}
if ( synPredMatched607 )
{
initializer=hash_literal();
}
else if ((LA(1)==LBRACE) && (tokenSet_74_.member(LA(2)))) {
initializer=list_initializer();
}
else
{
throw new NoViableAltException(LT(1), getFilename());
}
}
if (0==inputState.guessing)
{
e = new CollectionInitializationExpression(e, initializer);
}
}
else if ((tokenSet_75_.member(LA(1))) && (tokenSet_15_.member(LA(2)))) {
}
else
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
}
else
{
goto _loop608_breakloop;
}
}
_loop608_breakloop: ;
} // ( ... )*
}
catch (RecognitionException ex)
{
if (0 == inputState.guessing)
{
reportError(ex, "slicing_expression");
recover(ex,tokenSet_76_);
}
else
{
throw ex;
}
}
return e;
}
public override void LeaveMethodInvocationExpression(MethodInvocationExpression node)
{
if (node is MethodInvocationExpression && true && node.Target is MemberReferenceExpression)
{
MemberReferenceExpression memberReferenceExpression = (MemberReferenceExpression)node.Target;
if (true)
{
Expression target = memberReferenceExpression.Target;
if (true && memberReferenceExpression.Name == "GetComponent" && 1 == ((ICollection)node.Arguments).Count && node.Arguments[0] is StringLiteralExpression)
{
StringLiteralExpression stringLiteralExpression = (StringLiteralExpression)node.Arguments[0];
if (true)
{
string value = stringLiteralExpression.Value;
if (true)
{
TryCastExpression tryCastExpression = new TryCastExpression(LexicalInfo.Empty);
TryCastExpression arg_13A_0 = tryCastExpression;
MethodInvocationExpression methodInvocationExpression = new MethodInvocationExpression(LexicalInfo.Empty);
MethodInvocationExpression arg_10B_0 = methodInvocationExpression;
MemberReferenceExpression memberReferenceExpression2 = new MemberReferenceExpression(LexicalInfo.Empty);
string text = memberReferenceExpression2.Name = "GetComponent";
Expression expression = memberReferenceExpression2.Target = Expression.Lift(target);
Expression expression2 = arg_10B_0.Target = memberReferenceExpression2;
ExpressionCollection expressionCollection = methodInvocationExpression.Arguments = ExpressionCollection.FromArray(new Expression[]
{
Expression.Lift(value)
});
Expression expression3 = arg_13A_0.Target = methodInvocationExpression;
TypeReference typeReference = tryCastExpression.Type = TypeReference.Lift(value);
this.ReplaceCurrentNode(tryCastExpression);
return;
}
}
}
}
}
if (node is MethodInvocationExpression && true && node.Target is ReferenceExpression)
{
ReferenceExpression referenceExpression = (ReferenceExpression)node.Target;
if (true && referenceExpression.Name == "GetComponent" && 1 == ((ICollection)node.Arguments).Count && node.Arguments[0] is StringLiteralExpression)
{
StringLiteralExpression stringLiteralExpression2 = (StringLiteralExpression)node.Arguments[0];
if (true)
{
string value = stringLiteralExpression2.Value;
if (true)
{
TryCastExpression tryCastExpression2 = new TryCastExpression(LexicalInfo.Empty);
TryCastExpression arg_280_0 = tryCastExpression2;
MethodInvocationExpression methodInvocationExpression2 = new MethodInvocationExpression(LexicalInfo.Empty);
MethodInvocationExpression arg_251_0 = methodInvocationExpression2;
ReferenceExpression referenceExpression2 = new ReferenceExpression(LexicalInfo.Empty);
string text2 = referenceExpression2.Name = "GetComponent";
Expression expression4 = arg_251_0.Target = referenceExpression2;
ExpressionCollection expressionCollection2 = methodInvocationExpression2.Arguments = ExpressionCollection.FromArray(new Expression[]
{
Expression.Lift(value)
});
Expression expression5 = arg_280_0.Target = methodInvocationExpression2;
TypeReference typeReference2 = tryCastExpression2.Type = TypeReference.Lift(value);
this.ReplaceCurrentNode(tryCastExpression2);
return;
}
}
}
}
if (node is MethodInvocationExpression && true && node.Target is MemberReferenceExpression)
{
MemberReferenceExpression memberReferenceExpression3 = (MemberReferenceExpression)node.Target;
if (true)
{
Expression target = memberReferenceExpression3.Target;
if (true && memberReferenceExpression3.Name == "GetComponent" && 1 == ((ICollection)node.Arguments).Count && node.Arguments[0] is ReferenceExpression)
{
ReferenceExpression e = (ReferenceExpression)node.Arguments[0];
if (true)
{
MethodInvocationExpression methodInvocationExpression3 = new MethodInvocationExpression(LexicalInfo.Empty);
MethodInvocationExpression arg_3D8_0 = methodInvocationExpression3;
GenericReferenceExpression genericReferenceExpression = new GenericReferenceExpression(LexicalInfo.Empty);
GenericReferenceExpression arg_3A9_0 = genericReferenceExpression;
MemberReferenceExpression memberReferenceExpression4 = new MemberReferenceExpression(LexicalInfo.Empty);
string text3 = memberReferenceExpression4.Name = "GetComponent";
Expression expression6 = memberReferenceExpression4.Target = Expression.Lift(target);
Expression expression7 = arg_3A9_0.Target = memberReferenceExpression4;
TypeReferenceCollection typeReferenceCollection = genericReferenceExpression.GenericArguments = TypeReferenceCollection.FromArray(new TypeReference[]
{
TypeReference.Lift(e)
});
Expression expression8 = arg_3D8_0.Target = genericReferenceExpression;
this.ReplaceCurrentNode(methodInvocationExpression3);
return;
}
}
}
}
if (node is MethodInvocationExpression && true && node.Target is ReferenceExpression)
{
ReferenceExpression referenceExpression3 = (ReferenceExpression)node.Target;
if (true && referenceExpression3.Name == "GetComponent" && 1 == ((ICollection)node.Arguments).Count && node.Arguments[0] is ReferenceExpression)
{
ReferenceExpression e = (ReferenceExpression)node.Arguments[0];
if (true)
{
MethodInvocationExpression methodInvocationExpression4 = new MethodInvocationExpression(LexicalInfo.Empty);
MethodInvocationExpression arg_4F9_0 = methodInvocationExpression4;
GenericReferenceExpression genericReferenceExpression2 = new GenericReferenceExpression(LexicalInfo.Empty);
GenericReferenceExpression arg_4CA_0 = genericReferenceExpression2;
ReferenceExpression referenceExpression4 = new ReferenceExpression(LexicalInfo.Empty);
string text4 = referenceExpression4.Name = "GetComponent";
Expression expression9 = arg_4CA_0.Target = referenceExpression4;
TypeReferenceCollection typeReferenceCollection2 = genericReferenceExpression2.GenericArguments = TypeReferenceCollection.FromArray(new TypeReference[]
{
TypeReference.Lift(e)
});
Expression expression10 = arg_4F9_0.Target = genericReferenceExpression2;
this.ReplaceCurrentNode(methodInvocationExpression4);
return;
}
}
}
if (node is MethodInvocationExpression && true && node.Target is MemberReferenceExpression)
{
MemberReferenceExpression memberReferenceExpression5 = (MemberReferenceExpression)node.Target;
if (true)
{
Expression target = memberReferenceExpression5.Target;
if (true && memberReferenceExpression5.Name == "GetComponents" && 1 == ((ICollection)node.Arguments).Count && node.Arguments[0] is ReferenceExpression)
{
ReferenceExpression e = (ReferenceExpression)node.Arguments[0];
if (true)
{
MethodInvocationExpression methodInvocationExpression5 = new MethodInvocationExpression(LexicalInfo.Empty);
MethodInvocationExpression arg_63D_0 = methodInvocationExpression5;
GenericReferenceExpression genericReferenceExpression3 = new GenericReferenceExpression(LexicalInfo.Empty);
GenericReferenceExpression arg_60E_0 = genericReferenceExpression3;
MemberReferenceExpression memberReferenceExpression6 = new MemberReferenceExpression(LexicalInfo.Empty);
string text5 = memberReferenceExpression6.Name = "GetComponents";
Expression expression11 = memberReferenceExpression6.Target = Expression.Lift(target);
Expression expression12 = arg_60E_0.Target = memberReferenceExpression6;
TypeReferenceCollection typeReferenceCollection3 = genericReferenceExpression3.GenericArguments = TypeReferenceCollection.FromArray(new TypeReference[]
{
TypeReference.Lift(e)
});
Expression expression13 = arg_63D_0.Target = genericReferenceExpression3;
this.ReplaceCurrentNode(methodInvocationExpression5);
return;
}
}
}
}
if (node is MethodInvocationExpression && true && node.Target is ReferenceExpression)
{
ReferenceExpression referenceExpression5 = (ReferenceExpression)node.Target;
if (true && referenceExpression5.Name == "GetComponents" && 1 == ((ICollection)node.Arguments).Count && node.Arguments[0] is ReferenceExpression)
{
ReferenceExpression e = (ReferenceExpression)node.Arguments[0];
if (true)
{
MethodInvocationExpression methodInvocationExpression6 = new MethodInvocationExpression(LexicalInfo.Empty);
MethodInvocationExpression arg_75E_0 = methodInvocationExpression6;
GenericReferenceExpression genericReferenceExpression4 = new GenericReferenceExpression(LexicalInfo.Empty);
GenericReferenceExpression arg_72F_0 = genericReferenceExpression4;
ReferenceExpression referenceExpression6 = new ReferenceExpression(LexicalInfo.Empty);
string text6 = referenceExpression6.Name = "GetComponents";
Expression expression14 = arg_72F_0.Target = referenceExpression6;
TypeReferenceCollection typeReferenceCollection4 = genericReferenceExpression4.GenericArguments = TypeReferenceCollection.FromArray(new TypeReference[]
{
TypeReference.Lift(e)
});
Expression expression15 = arg_75E_0.Target = genericReferenceExpression4;
this.ReplaceCurrentNode(methodInvocationExpression6);
return;
}
}
}
if (node is MethodInvocationExpression && true && node.Target is MemberReferenceExpression)
{
MemberReferenceExpression memberReferenceExpression7 = (MemberReferenceExpression)node.Target;
if (true)
{
Expression target = memberReferenceExpression7.Target;
if (true && memberReferenceExpression7.Name == "GetComponentsInChildren" && 1 == ((ICollection)node.Arguments).Count && node.Arguments[0] is ReferenceExpression)
{
ReferenceExpression e = (ReferenceExpression)node.Arguments[0];
if (true)
{
MethodInvocationExpression methodInvocationExpression7 = new MethodInvocationExpression(LexicalInfo.Empty);
MethodInvocationExpression arg_8A2_0 = methodInvocationExpression7;
GenericReferenceExpression genericReferenceExpression5 = new GenericReferenceExpression(LexicalInfo.Empty);
GenericReferenceExpression arg_873_0 = genericReferenceExpression5;
MemberReferenceExpression memberReferenceExpression8 = new MemberReferenceExpression(LexicalInfo.Empty);
string text7 = memberReferenceExpression8.Name = "GetComponentsInChildren";
Expression expression16 = memberReferenceExpression8.Target = Expression.Lift(target);
Expression expression17 = arg_873_0.Target = memberReferenceExpression8;
TypeReferenceCollection typeReferenceCollection5 = genericReferenceExpression5.GenericArguments = TypeReferenceCollection.FromArray(new TypeReference[]
{
TypeReference.Lift(e)
});
Expression expression18 = arg_8A2_0.Target = genericReferenceExpression5;
this.ReplaceCurrentNode(methodInvocationExpression7);
return;
}
}
}
}
if (node is MethodInvocationExpression && true && node.Target is ReferenceExpression)
{
ReferenceExpression referenceExpression7 = (ReferenceExpression)node.Target;
if (true && referenceExpression7.Name == "GetComponentsInChildren" && 1 == ((ICollection)node.Arguments).Count && node.Arguments[0] is ReferenceExpression)
{
ReferenceExpression e = (ReferenceExpression)node.Arguments[0];
if (true)
{
MethodInvocationExpression methodInvocationExpression8 = new MethodInvocationExpression(LexicalInfo.Empty);
MethodInvocationExpression arg_9C3_0 = methodInvocationExpression8;
GenericReferenceExpression genericReferenceExpression6 = new GenericReferenceExpression(LexicalInfo.Empty);
GenericReferenceExpression arg_994_0 = genericReferenceExpression6;
ReferenceExpression referenceExpression8 = new ReferenceExpression(LexicalInfo.Empty);
string text8 = referenceExpression8.Name = "GetComponentsInChildren";
Expression expression19 = arg_994_0.Target = referenceExpression8;
TypeReferenceCollection typeReferenceCollection6 = genericReferenceExpression6.GenericArguments = TypeReferenceCollection.FromArray(new TypeReference[]
{
TypeReference.Lift(e)
});
Expression expression20 = arg_9C3_0.Target = genericReferenceExpression6;
this.ReplaceCurrentNode(methodInvocationExpression8);
return;
}
}
}
if (node is MethodInvocationExpression && true && node.Target is MemberReferenceExpression)
{
MemberReferenceExpression memberReferenceExpression9 = (MemberReferenceExpression)node.Target;
if (true)
{
Expression target = memberReferenceExpression9.Target;
if (true && memberReferenceExpression9.Name == "GetComponentInChildren" && 1 == ((ICollection)node.Arguments).Count && node.Arguments[0] is ReferenceExpression)
{
ReferenceExpression e = (ReferenceExpression)node.Arguments[0];
if (true)
{
MethodInvocationExpression methodInvocationExpression9 = new MethodInvocationExpression(LexicalInfo.Empty);
MethodInvocationExpression arg_B07_0 = methodInvocationExpression9;
GenericReferenceExpression genericReferenceExpression7 = new GenericReferenceExpression(LexicalInfo.Empty);
GenericReferenceExpression arg_AD8_0 = genericReferenceExpression7;
MemberReferenceExpression memberReferenceExpression10 = new MemberReferenceExpression(LexicalInfo.Empty);
string text9 = memberReferenceExpression10.Name = "GetComponentInChildren";
Expression expression21 = memberReferenceExpression10.Target = Expression.Lift(target);
Expression expression22 = arg_AD8_0.Target = memberReferenceExpression10;
TypeReferenceCollection typeReferenceCollection7 = genericReferenceExpression7.GenericArguments = TypeReferenceCollection.FromArray(new TypeReference[]
{
TypeReference.Lift(e)
});
Expression expression23 = arg_B07_0.Target = genericReferenceExpression7;
this.ReplaceCurrentNode(methodInvocationExpression9);
return;
}
}
}
}
if (node is MethodInvocationExpression && true && node.Target is ReferenceExpression)
{
ReferenceExpression referenceExpression9 = (ReferenceExpression)node.Target;
if (true && referenceExpression9.Name == "GetComponentInChildren" && 1 == ((ICollection)node.Arguments).Count && node.Arguments[0] is ReferenceExpression)
{
ReferenceExpression e = (ReferenceExpression)node.Arguments[0];
if (true)
{
MethodInvocationExpression methodInvocationExpression10 = new MethodInvocationExpression(LexicalInfo.Empty);
MethodInvocationExpression arg_C28_0 = methodInvocationExpression10;
GenericReferenceExpression genericReferenceExpression8 = new GenericReferenceExpression(LexicalInfo.Empty);
GenericReferenceExpression arg_BF9_0 = genericReferenceExpression8;
ReferenceExpression referenceExpression10 = new ReferenceExpression(LexicalInfo.Empty);
string text10 = referenceExpression10.Name = "GetComponentInChildren";
Expression expression24 = arg_BF9_0.Target = referenceExpression10;
TypeReferenceCollection typeReferenceCollection8 = genericReferenceExpression8.GenericArguments = TypeReferenceCollection.FromArray(new TypeReference[]
{
TypeReference.Lift(e)
});
Expression expression25 = arg_C28_0.Target = genericReferenceExpression8;
this.ReplaceCurrentNode(methodInvocationExpression10);
return;
}
}
}
if (node is MethodInvocationExpression && true && node.Target is MemberReferenceExpression)
{
MemberReferenceExpression memberReferenceExpression11 = (MemberReferenceExpression)node.Target;
if (true)
{
Expression target = memberReferenceExpression11.Target;
if (true && memberReferenceExpression11.Name == "AddComponent" && 1 == ((ICollection)node.Arguments).Count && node.Arguments[0] is StringLiteralExpression)
{
StringLiteralExpression stringLiteralExpression3 = (StringLiteralExpression)node.Arguments[0];
if (true)
{
string value = stringLiteralExpression3.Value;
if (true)
{
if (!this.isBinaryExp)
{
MethodInvocationExpression methodInvocationExpression11 = new MethodInvocationExpression(LexicalInfo.Empty);
MethodInvocationExpression arg_D49_0 = methodInvocationExpression11;
MemberReferenceExpression memberReferenceExpression12 = new MemberReferenceExpression(LexicalInfo.Empty);
string text11 = memberReferenceExpression12.Name = "AddComponent";
Expression expression26 = memberReferenceExpression12.Target = Expression.Lift(target);
Expression expression27 = arg_D49_0.Target = memberReferenceExpression12;
ExpressionCollection expressionCollection3 = methodInvocationExpression11.Arguments = ExpressionCollection.FromArray(new Expression[]
{
Expression.Lift(value)
});
this.ReplaceCurrentNode(methodInvocationExpression11);
this.isBinaryExp = false;
}
return;
}
}
}
}
}
if (node is MethodInvocationExpression && true && node.Target is ReferenceExpression)
{
ReferenceExpression referenceExpression11 = (ReferenceExpression)node.Target;
if (true && referenceExpression11.Name == "AddComponent" && 1 == ((ICollection)node.Arguments).Count && node.Arguments[0] is StringLiteralExpression)
{
StringLiteralExpression stringLiteralExpression4 = (StringLiteralExpression)node.Arguments[0];
if (true)
{
string value = stringLiteralExpression4.Value;
if (true)
{
if (!this.isBinaryExp)
{
MethodInvocationExpression methodInvocationExpression12 = new MethodInvocationExpression(LexicalInfo.Empty);
MethodInvocationExpression arg_E70_0 = methodInvocationExpression12;
ReferenceExpression referenceExpression12 = new ReferenceExpression(LexicalInfo.Empty);
string text12 = referenceExpression12.Name = "AddComponent";
Expression expression28 = arg_E70_0.Target = referenceExpression12;
ExpressionCollection expressionCollection4 = methodInvocationExpression12.Arguments = ExpressionCollection.FromArray(new Expression[]
{
Expression.Lift(value)
});
this.ReplaceCurrentNode(methodInvocationExpression12);
this.isBinaryExp = false;
}
return;
}
}
}
}
if (node is MethodInvocationExpression && true && node.Target is MemberReferenceExpression)
{
MemberReferenceExpression memberReferenceExpression13 = (MemberReferenceExpression)node.Target;
if (true)
{
Expression target = memberReferenceExpression13.Target;
if (true && memberReferenceExpression13.Name == "AddComponent" && 1 == ((ICollection)node.Arguments).Count && node.Arguments[0] is ReferenceExpression)
{
ReferenceExpression e = (ReferenceExpression)node.Arguments[0];
if (true)
{
MethodInvocationExpression methodInvocationExpression13 = new MethodInvocationExpression(LexicalInfo.Empty);
MethodInvocationExpression arg_FDD_0 = methodInvocationExpression13;
GenericReferenceExpression genericReferenceExpression9 = new GenericReferenceExpression(LexicalInfo.Empty);
GenericReferenceExpression arg_FAE_0 = genericReferenceExpression9;
MemberReferenceExpression memberReferenceExpression14 = new MemberReferenceExpression(LexicalInfo.Empty);
string text13 = memberReferenceExpression14.Name = "AddComponent";
Expression expression29 = memberReferenceExpression14.Target = Expression.Lift(target);
Expression expression30 = arg_FAE_0.Target = memberReferenceExpression14;
TypeReferenceCollection typeReferenceCollection9 = genericReferenceExpression9.GenericArguments = TypeReferenceCollection.FromArray(new TypeReference[]
{
TypeReference.Lift(e)
});
Expression expression31 = arg_FDD_0.Target = genericReferenceExpression9;
this.ReplaceCurrentNode(methodInvocationExpression13);
return;
}
}
}
}
if (node is MethodInvocationExpression && true && node.Target is ReferenceExpression)
{
ReferenceExpression referenceExpression13 = (ReferenceExpression)node.Target;
if (true && referenceExpression13.Name == "AddComponent" && 1 == ((ICollection)node.Arguments).Count && node.Arguments[0] is ReferenceExpression)
{
ReferenceExpression e = (ReferenceExpression)node.Arguments[0];
if (true)
{
MethodInvocationExpression methodInvocationExpression14 = new MethodInvocationExpression(LexicalInfo.Empty);
MethodInvocationExpression arg_10FE_0 = methodInvocationExpression14;
GenericReferenceExpression genericReferenceExpression10 = new GenericReferenceExpression(LexicalInfo.Empty);
GenericReferenceExpression arg_10CF_0 = genericReferenceExpression10;
ReferenceExpression referenceExpression14 = new ReferenceExpression(LexicalInfo.Empty);
string text14 = referenceExpression14.Name = "AddComponent";
Expression expression32 = arg_10CF_0.Target = referenceExpression14;
TypeReferenceCollection typeReferenceCollection10 = genericReferenceExpression10.GenericArguments = TypeReferenceCollection.FromArray(new TypeReference[]
{
TypeReference.Lift(e)
});
Expression expression33 = arg_10FE_0.Target = genericReferenceExpression10;
this.ReplaceCurrentNode(methodInvocationExpression14);
return;
}
}
}
if (node is MethodInvocationExpression && true && node.Target is ReferenceExpression)
{
ReferenceExpression referenceExpression15 = (ReferenceExpression)node.Target;
if (true && referenceExpression15.Name == "Instantiate" && 3 == ((ICollection)node.Arguments).Count)
{
Expression expression34 = node.Arguments[0];
if (true)
{
Expression expression35 = node.Arguments[1];
if (true)
{
expression35 = node.Arguments[2];
if (true)
{
IType expressionType = expression34.ExpressionType;
if (expressionType != null)
{
TryCastExpression tryCastExpression3 = new TryCastExpression(LexicalInfo.Empty);
Expression expression36 = tryCastExpression3.Target = Expression.Lift(node);
TypeReference typeReference3 = tryCastExpression3.Type = TypeReference.Lift(this.CodeBuilder.CreateTypeReference(expressionType));
this.ReplaceCurrentNode(tryCastExpression3);
}
}
}
}
}
}
}
private Expression CreateNullableInstantiation(Expression val, IType type)
{
MethodInvocationExpression mie = new MethodInvocationExpression();
GenericReferenceExpression gre = new GenericReferenceExpression();
gre.Target = new MemberReferenceExpression(new ReferenceExpression("System"), "Nullable");
gre.GenericArguments.Add(TypeReference.Lift(Nullable.GetUnderlyingType(((ExternalType) type).ActualType)));
mie.Target = gre;
if (null != val && !IsNull(val))
mie.Arguments.Add(val);
return mie;
}
public override void OnGenericReferenceExpression(GenericReferenceExpression node)
{
MakeTypeResult(ConstructTypeFromGenericReferenceExpression(node));
}
