public new static TypeReference Parse(ContextNode parent, IAbstractSyntaxTree lexerNode)
{
Contract.Requires(lexerNode.Type == Lexer.TokenType.Type || lexerNode.Type == Lexer.TokenType.FullSymbol);
Contract.Ensures(Contract.Result <TypeReference>() != null);
if (lexerNode.Type == Lexer.TokenType.FullSymbol)
{
TypeNode node = DotOperatorNode.Parse(parent, lexerNode) as TypeNode;
if (node != null)
{
return(node.ParsedType);
}
else
{
ErrorCode.TypeExpected.ReportAndThrow(parent.Parser.GetSequencePoint(lexerNode), "Type expected");
}
}
TypeBuilder builder = new TypeBuilder(parent);
foreach (var node in lexerNode.Children)
{
builder.Append(node);
}
return(builder.Type);
}
public static ExpressionNode Parse(ContextNode context, IAbstractSyntaxTree lexerNode, TypeReference expectedType = null)
{
Contract.Ensures(Contract.Result <ExpressionNode>() != null);
ExpressionNode ret = null;
switch (lexerNode.Type)
{
case Lexer.TokenType.FullSymbol:
case Lexer.TokenType.Symbol:
ret = DotOperatorNode.Parse(context, lexerNode);
break;
case Lexer.TokenType.LiteralNode:
ret = LiteralNode.Parse(context, lexerNode);
break;
case Lexer.TokenType.Value:
ret = ExpressionNode.Parse(context, lexerNode.Children[0], expectedType);
break;
case Lexer.TokenType.Function:
ret = MethodNode.Parse(context, lexerNode);
break;
case Lexer.TokenType.InfixNode:
ret = InfixParser.Parse(context, lexerNode);
break;
case Lexer.TokenType.PostfixNode:
case Lexer.TokenType.PrefixNode:
ret = UnaryOperators.Parse(context, lexerNode);
break;
case Lexer.TokenType.ParenthesesNode:
ret = ExpressionNode.Parse(context, lexerNode.Children[1], expectedType);
break;
case Lexer.TokenType.ArrayLiteral:
ret = ArrayCreationNode.Parse(context, lexerNode);
break;
case Lexer.TokenType.Null:
ret = NullNode.Parse(context, lexerNode);
break;
default:
ContractsHelper.AssumeUnreachable("Unknown expression type {0}", lexerNode.Type);
break;
}
if (!(expectedType == null || expectedType.IsAuto()))
{
var ambiguous = ret as IAmbiguousNode;
if (ambiguous != null)
{
ret = ambiguous.RemoveAmbiguity(context, expectedType);
}
}
return(ret);
}
public static ExpressionNode Parse(ContextNode context, IAbstractSyntaxTree lexerNode)
{
Contract.Requires(
lexerNode.Type == Lexer.TokenType.InfixNode && lexerNode.Children[2].Type == Lexer.TokenType.Period ||
lexerNode.Type == Lexer.TokenType.FullSymbol ||
lexerNode.Type == Lexer.TokenType.Symbol);
Contract.Ensures(Contract.Result <ExpressionNode>() != null);
var instance = new DotOperatorNode(context);
if (lexerNode.Type == Lexer.TokenType.Symbol)
{
instance.Append(new SymbolNode(lexerNode.Content, context, context.Parser.GetSequencePoint(lexerNode)));
return(instance.builtNode);
}
foreach (var node in lexerNode.Children)
{
var point = context.Parser.GetSequencePoint(node);
switch (node.Type)
{
case Lexer.TokenType.Period:
break;
case Lexer.TokenType.Symbol:
instance.Append(new SymbolNode(node.Content, context, point));
break;
default:
instance.Append(ExpressionNode.Parse(context, node));
break;
}
}
return(instance.builtNode);
}
