public object VisitInvocationExpression(InvocationExpression ie, object data)
{
B.Expression e = ConvertExpression(ie.TargetObject);
if (e == null)
{
return(null);
}
if (settings.IsVisualBasic && ie.TargetObject is IdentifierExpression && currentStatement != null)
{
VariableResolver resolver = new VariableResolver(nameComparer);
TypeReference typeRef = resolver.FindType((ie.TargetObject as IdentifierExpression).Identifier, currentStatement);
if (typeRef != null && typeRef.IsArrayType)
{
// Visual Basic: indexer expression
B.SlicingExpression s = new B.SlicingExpression(GetLexicalInfo(ie));
s.Target = e;
foreach (Expression expr in ie.Arguments)
{
s.Indices.Add(new B.Slice(ConvertExpression(expr)));
}
return(s);
}
}
B.MethodInvocationExpression r = new B.MethodInvocationExpression(GetLexicalInfo(ie), e);
foreach (Expression expr in ie.Arguments)
{
e = ConvertExpression(expr);
if (e != null)
{
r.Arguments.Add(e);
}
}
return(r);
}
override public object Clone()
{
SlicingExpression clone = (SlicingExpression)FormatterServices.GetUninitializedObject(typeof(SlicingExpression));
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 != _indices)
{
clone._indices = _indices.Clone() as SliceCollection;
clone._indices.InitializeParent(clone);
}
return(clone);
}
override public object Clone()
{
SlicingExpression clone = new SlicingExpression();
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 != _indices)
{
clone._indices = _indices.Clone() as SliceCollection;
clone._indices.InitializeParent(clone);
}
return(clone);
}
public object VisitIndexerExpression(IndexerExpression indexerExpression, object data)
{
B.SlicingExpression s = new B.SlicingExpression(GetLexicalInfo(indexerExpression));
s.Target = ConvertExpression(indexerExpression.TargetObject);
foreach (Expression expr in indexerExpression.Indexes)
{
s.Indices.Add(new B.Slice(ConvertExpression(expr)));
}
return(s);
}
public override void OnSlicingExpression(SlicingExpression node)
{
base.OnSlicingExpression(node);
var arrayType = GetExpressionType(node.Target) as IArrayType;
if (arrayType == null)
return;
if (arrayType.Rank != node.Indices.Count)
Error(CompilerErrorFactory.InvalidArrayRank(node, node.Target.ToCodeString(), arrayType.Rank, node.Indices.Count));
}
public static bool IsComplexSlicing(SlicingExpression node)
{
foreach (Slice slice in node.Indices)
{
if (IsComplexSlice(slice))
{
return(true);
}
}
return(false);
}
public override void LeaveSlicingExpression(SlicingExpression node)
{
if (IsDuckTyped(node.Target) && !HasDefaultMember(node.Target))
{
BindDuck(node);
}
else
{
base.LeaveSlicingExpression(node);
}
}
private void ExpandComplexSlicing(SlicingExpression node)
{
var targetType = GetExpressionType(node.Target);
if (IsString(targetType))
ExpandComplexStringSlicing(node);
else if (IsList(targetType))
ExpandComplexListSlicing(node);
else if (targetType.IsArray)
ExpandComplexArraySlicing(node);
else
NotImplemented(node, "complex slicing for anything but lists, arrays and strings");
}
void ExpandComplexArraySlicing(SlicingExpression node)
{
if (node.Indices.Count > 1)
{
MethodInvocationExpression mie = null;
var computeEnd = new ArrayLiteralExpression();
var collapse = new ArrayLiteralExpression();
var ranges = new ArrayLiteralExpression();
for (int i = 0; i < node.Indices.Count; i++)
{
ranges.Items.Add(node.Indices[i].Begin);
if (node.Indices[i].End == null )
{
var end = new BinaryExpression(BinaryOperatorType.Addition, node.Indices[i].Begin, new IntegerLiteralExpression(1));
ranges.Items.Add(end);
BindExpressionType(end, GetExpressionType(node.Indices[i].Begin));
computeEnd.Items.Add(new BoolLiteralExpression(false));
collapse.Items.Add(new BoolLiteralExpression(true));
}
else if (node.Indices[i].End == OmittedExpression.Default)
{
var end = new IntegerLiteralExpression(0);
ranges.Items.Add(end);
BindExpressionType(end, GetExpressionType(node.Indices[i].Begin));
computeEnd.Items.Add(new BoolLiteralExpression(true));
collapse.Items.Add(new BoolLiteralExpression(false));
}
else
{
ranges.Items.Add(node.Indices[i].End);
computeEnd.Items.Add(new BoolLiteralExpression(false));
collapse.Items.Add(new BoolLiteralExpression(false));
}
}
mie = CodeBuilder.CreateMethodInvocation(MethodCache.RuntimeServices_GetMultiDimensionalRange1, node.Target, ranges);
mie.Arguments.Add(computeEnd);
mie.Arguments.Add(collapse);
BindExpressionType(ranges, TypeSystemServices.Map(typeof(int[])));
BindExpressionType(computeEnd, TypeSystemServices.Map(typeof(bool[])));
BindExpressionType(collapse, TypeSystemServices.Map(typeof(bool[])));
node.ParentNode.Replace(node, mie);
}
else
{
var slice = node.Indices[0];
var mie = IsNullOrOmitted(slice.End)
? CodeBuilder.CreateMethodInvocation(MethodCache.RuntimeServices_GetRange1, node.Target, slice.Begin)
: CodeBuilder.CreateMethodInvocation(MethodCache.RuntimeServices_GetRange2, node.Target, slice.Begin, slice.End);
node.ParentNode.Replace(node, mie);
}
}
public override void OnSlicingExpression(SlicingExpression node)
{
base.OnSlicingExpression(node);
if (!node.IsComplexSlicing())
return;
if (node.IsTargetOfAssignment())
return;
CompleteOmittedExpressions(node);
ExpandComplexSlicing(node);
}
void ExpandComplexListSlicing(SlicingExpression node)
{
var slice = node.Indices[0];
MethodInvocationExpression mie;
if (IsNullOrOmitted(slice.End))
{
mie = CodeBuilder.CreateMethodInvocation(node.Target, MethodCache.List_GetRange1);
mie.Arguments.Add(slice.Begin);
}
else
{
mie = CodeBuilder.CreateMethodInvocation(node.Target, MethodCache.List_GetRange2);
mie.Arguments.Add(slice.Begin);
mie.Arguments.Add(slice.End);
}
node.ParentNode.Replace(node, mie);
}
public override void Apply(Node targetNode) {
var cls = targetNode as ClassDefinition;
if(cls==null) {
this.Context.Errors.Add(new CompilerError(this.LexicalInfo,
"ControllerAttribute is applyable only to classes"));
return;
}
targetNode.GetEnclosingModule().Imports.Add(new Import(this.LexicalInfo,"Comdiv.Controllers"));
cls.BaseTypes.Clear();
cls.BaseTypes.Insert(0, new SimpleTypeReference("Comdiv.Controllers.ExtensionBaseController"));
if(!cls.Name.EndsWith("Controller")) {
cls.Name = cls.Name + "Controller";
}
var body = targetNode.GetEnclosingModule()["regmethod"] as Block;
var registrycall = new SlicingExpression(new ReferenceExpression("registry"), new StringLiteralExpression(cls.Name.ToLower()));
var assign = new ReferenceExpression(cls.Name);
var aexpr = new BinaryExpression(BinaryOperatorType.Assign, registrycall, assign);
body.Add(aexpr);
}
private void tryClass(Node targetNode) {
var cls = targetNode as ClassDefinition;
if (cls == null)
{
return;
}
if (cls.BaseTypes.Count == 0)
{
cls.BaseTypes.Insert(0, new SimpleTypeReference("Comdiv.Framework.Quick.QuickBase"));
}
var attr = new Attribute("Comdiv.Framework.Quick.actionAttribute");
attr.Arguments.Add(new StringLiteralExpression(cls.Name.Replace("_", ".")));
cls.Attributes.Add(attr);
var body = targetNode.GetEnclosingModule()["regmethod"] as Block;
var registrycall = new SlicingExpression(new ReferenceExpression("registry"), new StringLiteralExpression(cls.Name.Replace("_", ".") + ".quick"));
var assign = new ReferenceExpression(cls.Name);
var aexpr = new BinaryExpression(BinaryOperatorType.Assign, registrycall, assign);
body.Add(aexpr);
}
override public void OnSlicingExpression(SlicingExpression node)
{
var tern = ProcessTargets(node);
if (tern != null)
{
Visit(node.Indices);
ReplaceCurrentNode(tern);
}
base.OnSlicingExpression(node);
}
private ArrayLiteralExpression GetArrayForIndices(SlicingExpression node)
{
ArrayLiteralExpression args = new ArrayLiteralExpression();
foreach (Slice index in node.Indices)
{
if (AstUtil.IsComplexSlice(index))
{
throw CompilerErrorFactory.NotImplemented(index, "complex slice for duck");
}
args.Items.Add(index.Begin);
}
BindExpressionType(args, TypeSystemServices.ObjectArrayType);
return args;
}
private static Expression GetSlicingTarget(SlicingExpression node)
{
Expression target = node.Target;
if (NodeType.MemberReferenceExpression == target.NodeType)
{
MemberReferenceExpression mre = ((MemberReferenceExpression)target);
return mre.Target;
}
return target;
}
private IType ResultingTypeForComplexSlicing(SlicingExpression node)
{
var targetType = GetExpressionType(node.Target);
return targetType.IsArray ? ResultingTypeForArraySlicing(node) : targetType;
}
public override void OnSlicingExpression(SlicingExpression node)
{
if (AstUtil.IsLhsOfAssignment(node))
return;
Visit(node.Target);
IArrayType type = (IArrayType)PopType();
EmitNormalizedArrayIndex(node, node.Indices[0].Begin);
IType elementType = type.ElementType;
OpCode opcode = GetLoadEntityOpCode(elementType);
if (OpCodes.Ldelema.Value == opcode.Value)
{
Type systemType = GetSystemType(elementType);
_il.Emit(opcode, systemType);
if (!IsByAddress(elementType))
_il.Emit(OpCodes.Ldobj, systemType);
}
else if (OpCodes.Ldelem.Value == opcode.Value)
{
_il.Emit(opcode, GetSystemType(elementType));
}
else
{
_il.Emit(opcode);
}
PushType(elementType);
}
void AssertIsNotComplexSlicing(SlicingExpression node)
{
if (node.IsComplexSlicing())
NotImplemented(node, "complex slicing");
}
protected void slice(
SlicingExpression se
) //throws RecognitionException, TokenStreamException
{
Expression begin = null;
Expression end = null;
Expression step = null;
try { // for error handling
{
switch ( LA(1) )
{
case COLON:
{
{
match(COLON);
if (0==inputState.guessing)
{
begin = OmittedExpression.Default;
}
{
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:
{
end=expression();
break;
}
case COLON:
{
{
match(COLON);
if (0==inputState.guessing)
{
end = OmittedExpression.Default;
}
step=expression();
}
break;
}
case RBRACK:
case COMMA:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
}
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 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:
{
begin=expression();
{
switch ( LA(1) )
{
case COLON:
{
match(COLON);
{
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:
{
end=expression();
break;
}
case RBRACK:
case COMMA:
case COLON:
{
if (0==inputState.guessing)
{
end = OmittedExpression.Default;
}
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
{
switch ( LA(1) )
{
case COLON:
{
match(COLON);
step=expression();
break;
}
case RBRACK:
case COMMA:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
break;
}
case RBRACK:
case COMMA:
{
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
break;
}
default:
{
throw new NoViableAltException(LT(1), getFilename());
}
}
}
if (0==inputState.guessing)
{
se.Indices.Add(new Slice(begin, end, step));
}
}
catch (RecognitionException ex)
{
if (0 == inputState.guessing)
{
reportError(ex, "slice");
recover(ex,tokenSet_52_);
}
else
{
throw ex;
}
}
}
//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;
}
private Expression CreateSideEffectAwareSlicingOperation(LexicalInfo lexicalInfo, BinaryOperatorType binaryOperator, SlicingExpression lvalue, Expression rvalue, InternalLocal returnValue)
{
MethodInvocationExpression eval = CodeBuilder.CreateEvalInvocation(lexicalInfo);
if (HasSideEffect(lvalue.Target))
{
InternalLocal temp = AddInitializedTempLocal(eval, lvalue.Target);
lvalue.Target = CodeBuilder.CreateReference(temp);
}
foreach (Slice slice in lvalue.Indices)
{
Expression index = slice.Begin;
if (HasSideEffect(index))
{
InternalLocal temp = AddInitializedTempLocal(eval, index);
slice.Begin = CodeBuilder.CreateReference(temp);
}
}
BinaryExpression addition = CodeBuilder.CreateBoundBinaryExpression(
GetExpressionType(lvalue),
binaryOperator,
CloneOrAssignToTemp(returnValue, lvalue),
rvalue);
Expression expansion = CodeBuilder.CreateAssignment(
lvalue.CloneNode(),
addition);
// Resolve operator overloads if any
BindArithmeticOperator(addition);
if (eval.Arguments.Count > 0 || null != returnValue)
{
eval.Arguments.Add(expansion);
if (null != returnValue)
{
eval.Arguments.Add(CodeBuilder.CreateReference(returnValue));
}
BindExpressionType(eval, GetExpressionType(lvalue));
expansion = eval;
}
return expansion;
}
void EmitNormalizedArrayIndex(SlicingExpression sourceNode, Expression index)
{
bool isNegative = false;
if (CanBeNegative(index, ref isNegative)
&& !_rawArrayIndexing
&& !AstAnnotations.IsRawIndexing(sourceNode))
{
if (isNegative)
{
_il.Emit(OpCodes.Dup);
_il.Emit(OpCodes.Ldlen);
EmitLoadInt(index);
_il.Emit(OpCodes.Add);
}
else
{
_il.Emit(OpCodes.Dup);
EmitLoadInt(index);
_il.EmitCall(OpCodes.Call, RuntimeServices_NormalizeArrayIndex, null);
}
}
else
{
EmitLoadInt(index);
}
}
public override void LeaveSlicingExpression(SlicingExpression node)
{
if (node.Target.Entity.IsAmbiguous())
{
BindIndexedPropertySlicing(node);
return;
}
// target[indices]
var targetType = GetExpressionType(node.Target);
if (IsError(targetType))
{
Error(node);
return;
}
if (node.IsComplexSlicing())
{
BindExpressionType(node, ResultingTypeForComplexSlicing(node));
return;
}
if (IsIndexedProperty(node.Target))
{
BindIndexedPropertySlicing(node);
return;
}
if (targetType.IsArray)
{
BindExpressionType(node, targetType.ElementType);
return;
}
var member = TypeSystemServices.GetDefaultMember(targetType);
if (member == null)
{
Error(node, CompilerErrorFactory.TypeDoesNotSupportSlicing(node.Target, targetType));
return;
}
node.Target = new MemberReferenceExpression(node.LexicalInfo, node.Target, member.Name)
{
Entity = member,
ExpressionType = Null.Default // to be resolved later
};
SliceMember(node, member);
}
void BindMultiDimensionalArraySlicing(SlicingExpression node)
{
if (AstUtil.IsLhsOfAssignment(node))
{
// leave it to LeaveBinaryExpression to resolve
return;
}
MethodInvocationExpression mie = CodeBuilder.CreateMethodInvocation(
node.Target,
CachedMethod("Array_GetValue", () => Methods.InstanceFunctionOf<Array, int[], object>(a => a.GetValue)));
for (int i = 0; i < node.Indices.Count; i++)
{
mie.Arguments.Add(node.Indices[i].Begin);
}
IType elementType = node.Target.ExpressionType.ElementType;
node.ParentNode.Replace(node, CodeBuilder.CreateCast(elementType, mie));
}
public static bool IsComplexSlicing(this SlicingExpression node)
{
return(node.Indices.Any(IsComplexSlice));
}
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;
}
bool CheckComplexSlicingParameters(SlicingExpression node)
{
foreach (Slice slice in node.Indices)
{
if (!CheckComplexSlicingParameters(slice))
{
return false;
}
}
return true;
}
private void BindIndexedPropertySlicing(SlicingExpression node)
{
AssertIsNotComplexSlicing(node);
SliceMember(node, node.Target.Entity);
}
void CheckNoComplexSlicing(SlicingExpression node)
{
if (AstUtil.IsComplexSlicing(node))
{
NotImplemented(node, "complex slicing");
}
}
private Expression GetIndexedPropertySlicingTarget(SlicingExpression node)
{
Expression target = node.Target;
MemberReferenceExpression mre = target as MemberReferenceExpression;
if (null != mre) return mre.Target;
return CreateSelfReference();
}
public override void LeaveSlicingExpression(SlicingExpression node)
{
if (IsAmbiguous(node.Target.Entity))
{
BindIndexedPropertySlicing(node);
return;
}
// target[indices]
IType targetType = GetExpressionType(node.Target);
if (IsError(targetType))
{
Error(node);
return;
}
if (IsIndexedProperty(node.Target))
{
BindIndexedPropertySlicing(node);
}
else
{
if (targetType.IsArray)
{
IArrayType arrayType = (IArrayType)targetType;
if (arrayType.Rank != node.Indices.Count)
{
Error(node, CompilerErrorFactory.InvalidArrayRank(node, node.Target.ToString(), arrayType.Rank, node.Indices.Count));
}
if (AstUtil.IsComplexSlicing(node))
{
BindComplexArraySlicing(node);
}
else
{
if (arrayType.Rank > 1)
{
BindMultiDimensionalArraySlicing(node);
}
else
{
BindExpressionType(node, arrayType.ElementType);
}
}
}
else
{
if (AstUtil.IsComplexSlicing(node))
{
if (TypeSystemServices.StringType == targetType)
{
BindComplexStringSlicing(node);
}
else
{
if (IsAssignableFrom(TypeSystemServices.ListType, targetType))
{
BindComplexListSlicing(node);
}
else
{
NotImplemented(node, "complex slicing for anything but lists, arrays and strings");
}
}
}
else
{
IEntity member = TypeSystemServices.GetDefaultMember(targetType);
if (null == member)
{
Error(node, CompilerErrorFactory.TypeDoesNotSupportSlicing(node.Target, targetType.ToString()));
}
else
{
node.Target = new MemberReferenceExpression(node.LexicalInfo, node.Target, member.Name);
node.Target.Entity = member;
// to be resolved later
node.Target.ExpressionType = Null.Default;
SliceMember(node, member);
}
}
}
}
}
IType ResultingTypeForArraySlicing(SlicingExpression node)
{
var arrayType = GetExpressionType(node.Target);
if (node.Indices.Count > 1)
{
var collapseCount = node.Indices.Count(t => t.End == null);
return arrayType.ElementType.MakeArrayType(node.Indices.Count - collapseCount);
}
return arrayType;
}
override public void LeaveSlicingExpression(SlicingExpression node)
{
if (!IsDuckTyped(node.Target)) return;
if (AstUtil.IsLhsOfAssignment(node)) return;
// todo
// a[foo]
// RuntimeServices.GetSlice(a, "", (foo,))
MethodInvocationExpression mie = CodeBuilder.CreateMethodInvocation(
node.LexicalInfo,
RuntimeServices_GetSlice,
GetSlicingTarget(node),
CodeBuilder.CreateStringLiteral(GetSlicingMemberName(node)),
GetArrayForIndices(node));
Replace(mie);
}
void SliceMember(SlicingExpression node, IEntity member)
{
EnsureRelatedNodeWasVisited(node, member);
if (node.IsTargetOfAssignment())
{
// leave it to LeaveBinaryExpression to resolve
Bind(node, member);
return;
}
MethodInvocationExpression mie = new MethodInvocationExpression(node.LexicalInfo);
foreach (Slice index in node.Indices)
{
mie.Arguments.Add(index.Begin);
}
IMethod getter = null;
if (EntityType.Ambiguous == member.EntityType)
{
IEntity result = ResolveAmbiguousPropertyReference((ReferenceExpression)node.Target, (Ambiguous)member, mie.Arguments);
IProperty found = result as IProperty;
if (null != found)
{
getter = found.GetGetMethod();
}
else if (EntityType.Ambiguous == result.EntityType)
{
Error(node);
return;
}
}
else if (EntityType.Property == member.EntityType)
{
getter = ((IProperty)member).GetGetMethod();
}
if (null != getter)
{
if (AssertParameters(node, getter, mie.Arguments))
{
Expression target = GetIndexedPropertySlicingTarget(node);
mie.Target = CodeBuilder.CreateMemberReference(target, getter);
BindExpressionType(mie, getter.ReturnType);
node.ParentNode.Replace(node, mie);
}
else
{
Error(node);
}
}
else
{
NotImplemented(node, "slice for anything but arrays and default properties");
}
}
private static string GetSlicingMemberName(SlicingExpression node)
{
if (NodeType.MemberReferenceExpression == node.Target.NodeType)
{
MemberReferenceExpression mre = ((MemberReferenceExpression)node.Target);
return mre.Name;
}
return "";
}
