internal static TypeName ParseTypeName(AstNode parent)
{
// leading
TypeName leftTypeName = null;
// tuple
if (parent.Peek.Is(OpenParenthesis))
{
var tuple = new TupleTypeName(parent);
leftTypeName = tuple.Types.Count == 1
? tuple.Types[0]
: tuple;
}
// simple
else if (parent.EnsureNext(Identifier))
{
leftTypeName = new SimpleTypeName(NameExpression.ParseName(parent));
}
if (leftTypeName == null)
{
return(new SimpleTypeName("UnknownType"));
}
// middle
// generic ('[' followed by not ']')
if (parent.Peek.Is(OpenBracket) &&
!parent.PeekByIs(2, CloseBracket))
{
leftTypeName = new GenericTypeName(parent, leftTypeName);
}
// array
if (parent.Peek.Is(OpenBracket))
{
leftTypeName = new ArrayTypeName(parent, leftTypeName);
}
// trailing
// union
if (parent.Peek.Is(OpBitOr))
{
leftTypeName = new UnionTypeName(parent, leftTypeName);
}
return(leftTypeName);
}
/// <summary>
/// <c>
/// atom
/// : name
/// | await_expr
/// | yield_expr
/// | type_initializer_expr
/// | parenthesis_expr
/// | list_expr
/// | hash_collection
/// | CONSTANT
/// </c>
/// </summary>
internal static Expression ParseAtomExpr(AstNode parent)
{
Expression value;
switch (parent.Peek.Type)
{
case Identifier: {
value = NameExpression.ParseName(parent);
break;
}
case KeywordIf: {
return(new ConditionalExpression(parent));
}
case KeywordWhile: {
return(new WhileExpression(parent));
}
#region Small statements
case Semicolon:
case KeywordPass: {
return(new EmptyExpression(parent));
}
case KeywordBreak: {
return(new BreakExpression(parent));
}
case KeywordContinue: {
return(new ContinueExpression(parent));
}
case KeywordReturn: {
return(new ReturnExpression(parent));
}
case KeywordAwait: {
value = new AwaitExpression(parent);
break;
}
case KeywordYield: {
value = new YieldExpression(parent);
break;
}
#endregion
case KeywordModule: {
return(new ModuleDefinition(parent));
}
case KeywordClass: {
return(new ClassDefinition(parent));
}
case KeywordEnum: {
return(new EnumDefinition(parent));
}
case KeywordFn: {
return(new FunctionDefinition(parent));
}
case OpenBrace when parent.Ast.MacroExpectationType != typeof(BlockExpression): {
value = new BraceCollectionExpression(parent);
break;
}
case Indent:
case OpenBrace:
case Colon when parent.Ast.MacroExpectationType == typeof(BlockExpression): {
value = new BlockExpression(parent);
break;
}
case DoubleOpenBrace: {
value = new CodeQuoteExpression(parent);
break;
}
case OpenParenthesis: {
Token start = parent.Token;
parent.Eat(OpenParenthesis);
// empty tuple
if (parent.MaybeEat(CloseParenthesis))
{
return(new TupleExpression(parent, start, parent.Token));
}
value = ParseMultiple(parent, parens: true);
parent.Eat(CloseParenthesis);
break;
}
default: {
if (Spec.Constants.Contains(parent.Peek.Type))
{
parent.GetNext();
// TODO add pre-concatenation of literals
value = new ConstantExpression(parent);
}
else
{
value = ParseMacroApplication(parent);
}
break;
}
}
return(value);
}
