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); }