private BaseExpressionSyntax ParseCoreExpression()
{
var expression = this.ParseTerminalExpression();
while (this.index < this.tokens.Count)
{
switch (this.Peek())
{
case TokenKind.Dot:
var dotToken = this.Eat(TokenKind.Dot);
var identifierToken = this.Eat(TokenKind.Identifier);
expression = new ObjectAccessExpressionSyntax(expression, dotToken, identifierToken);
break;
case TokenKind.LeftBracket:
var leftBracketToken = this.Eat(TokenKind.LeftBracket);
var indexExpression = this.ParseBaseExpression();
var rightBracketToken = this.Eat(TokenKind.RightBracket);
expression = new ArrayAccessExpressionSyntax(expression, leftBracketToken, indexExpression, rightBracketToken);
break;
case TokenKind.LeftParen:
var leftParenToken = this.Eat(TokenKind.LeftParen);
var arguments = this.ParseArguments();
var rightParenToken = this.Eat(TokenKind.RightParen);
expression = new InvocationExpressionSyntax(expression, leftParenToken, arguments, rightParenToken);
break;
default:
return(expression);
}
}
return(expression);
}
public virtual void Visit(ArrayAccessExpressionSyntax arrayAccessExpressionSyntax)
{
Visit(arrayAccessExpressionSyntax.Owner);
foreach (var expressionSyntax in arrayAccessExpressionSyntax.Parameter)
{
Visit(expressionSyntax);
}
}
public override void Visit(ArrayAccessExpressionSyntax pNode)
{
if (!pNode.Identifier.Type.IsArray && pNode.Identifier.Type != SmallType.String)
{
Compiler.ReportError("Array access used on non array");
}
base.Visit(pNode);
}
public BoundArrayAccessExpression(ArrayAccessExpressionSyntax syntax, bool hasValue, bool hasErrors, string name, IReadOnlyList <BaseBoundExpression> indices)
: base(hasValue, hasErrors)
{
Debug.Assert(!syntax.IsDefault(), "'syntax' must not be null.");
Debug.Assert(!name.IsDefault(), "'name' must not be null.");
Debug.Assert(!indices.IsDefault(), "'indices' must not be null.");
this.Syntax = syntax;
this.Name = name;
this.Indices = indices;
}
public override SyntaxNode Visit(ArrayAccessExpressionSyntax pNode)
{
var n = pNode.Identifier.Accept <IdentifierSyntax>(this);
ExpressionSyntax i = null;
using (new ContextValue(this, "MemberContext", new MemberAccessContext()))
{
i = pNode.Index.Accept <ExpressionSyntax>(this);
}
return(SyntaxFactory.ArrayAccessExpression(n, i));
}
private BaseBoundExpression BindArrayAccessExpression(ArrayAccessExpressionSyntax syntax)
{
BaseBoundExpression baseExpression = this.BindExpression(syntax.BaseExpression);
BaseBoundExpression indexExpression = this.BindExpression(syntax.IndexExpression);
string arrayName;
List <BaseBoundExpression> indices = new List <BaseBoundExpression>();
bool hasErrors = baseExpression.HasErrors || indexExpression.HasErrors;
switch (baseExpression)
{
case BoundArrayAccessExpression arrayAccess:
{
arrayName = arrayAccess.Name;
indices.AddRange(arrayAccess.Indices);
indices.Add(indexExpression);
break;
}
case BoundVariableExpression variable:
{
arrayName = variable.Name;
indices.Add(indexExpression);
break;
}
default:
{
if (!hasErrors)
{
hasErrors = true;
this.diagnostics.ReportUnsupportedArrayBaseExpression(syntax.BaseExpression.Range);
}
return(new BoundInvalidExpression(syntax, hasValue: true, hasErrors));
}
}
return(new BoundArrayAccessExpression(syntax, hasValue: true, hasErrors, arrayName, indices));
}
public BoundArrayAccessExpression(List<BoundExpression> parameter, ArrayAccessExpressionSyntax syntax, IType type)
: base(syntax, type)
{
Parameter = parameter;
}
private BoundArrayAccessExpression BindArrayAccessExpression(ArrayAccessExpressionSyntax syntax)
{
var boundExpression = BindExpression(syntax.Owner);
Ensure(() => boundExpression.Type is ArrayCompilerGeneratedType, $"{boundExpression.Type} is no array");
var arrayType = (ArrayCompilerGeneratedType)boundExpression.Type;
var elementType = arrayType.Type;
var boundParameter = syntax.Parameter.Select(x => BindExpression(x)).ToList();
Ensure(() => boundParameter.Count == arrayType.Dimension, $"Parameter count ({boundParameter.Count}) must match array dimension count ({arrayType.Dimension})");
return new BoundArrayAccessExpression(boundParameter, syntax, elementType );
}