[Syntax] Introduce UnresolvedIsExpr/UnresolvedAsExpr

SequenceExprSyntax should have odd number elements. Previously 'a as b'
was parsed like:
```
(sequence_expr
  (identifier_expr "a"),
  (as_expr
    'as'
    (typeidentifier "b")))
```
So it had even number elements. Now it's parsed
```
(sequence_expr
  (identifier_expr "a"),
  (unresolved_as_expr 'as')
  (type_expr
    (typeidentifier "b")))
```

Author: rintaro

lib/Parse/ParseExpr.cpp

@@ -72,9 +72,15 @@ ParserResult<Expr> Parser::parseExprImpl(Diag<> Message,
 ///   expr-is:
 ///     'is' type
 ParserResult<Expr> Parser::parseExprIs() {
-  SourceLoc isLoc = consumeToken(tok::kw_is);
+  SourceLoc isLoc;
+  {
+    SyntaxParsingContext IsExprCtx(SyntaxContext, SyntaxKind::UnresolvedIsExpr);
+    isLoc = consumeToken(tok::kw_is);
+  }
 
   ParserResult<TypeRepr> type = parseType(diag::expected_type_after_is);
+  SyntaxContext->createNodeInPlace(SyntaxKind::TypeExpr);
+
   if (type.hasCodeCompletion())
     return makeParserCodeCompletionResult<Expr>();
   if (type.isNull())
@@ -89,19 +95,25 @@ ParserResult<Expr> Parser::parseExprIs() {
 ///     'as?' type
 ///     'as!' type
 ParserResult<Expr> Parser::parseExprAs() {
-  // Parse the 'as'.
-  SourceLoc asLoc = consumeToken(tok::kw_as);
-
-  // Parse the postfix '?'.
+  SourceLoc asLoc;
   SourceLoc questionLoc;
   SourceLoc exclaimLoc;
-  if (Tok.is(tok::question_postfix)) {
-    questionLoc = consumeToken(tok::question_postfix);
-  } else if (Tok.is(tok::exclaim_postfix)) {
-    exclaimLoc = consumeToken(tok::exclaim_postfix);
+
+  {
+    SyntaxParsingContext AsExprCtx(SyntaxContext, SyntaxKind::UnresolvedAsExpr);
+    // Parse the 'as'.
+    asLoc = consumeToken(tok::kw_as);
+
+    // Parse the postfix '?'.
+    if (Tok.is(tok::question_postfix)) {
+      questionLoc = consumeToken(tok::question_postfix);
+    } else if (Tok.is(tok::exclaim_postfix)) {
+      exclaimLoc = consumeToken(tok::exclaim_postfix);
+    }
   }
 
   ParserResult<TypeRepr> type = parseType(diag::expected_type_after_as);
+  SyntaxContext->createNodeInPlace(SyntaxKind::TypeExpr);
 
   if (type.hasCodeCompletion())
     return makeParserCodeCompletionResult<Expr>();
@@ -295,7 +307,6 @@ ParserResult<Expr> Parser::parseExprSequence(Diag<> Message,
     }
 
     case tok::kw_is: {
-      SyntaxParsingContext IsContext(SyntaxContext, SyntaxKind::IsExpr);
       // Parse a type after the 'is' token instead of an expression.
       ParserResult<Expr> is = parseExprIs();
       if (is.isNull() || is.hasCodeCompletion())
@@ -313,7 +324,6 @@ ParserResult<Expr> Parser::parseExprSequence(Diag<> Message,
     }
 
     case tok::kw_as: {
-      SyntaxParsingContext AsContext(SyntaxContext, SyntaxKind::AsExpr);
       ParserResult<Expr> as = parseExprAs();
       if (as.isNull() || as.hasCodeCompletion())
         return as;

lib/Parse/SyntaxParsingContext.cpp

@@ -278,7 +278,8 @@ void SyntaxParsingContext::createNodeInPlace(SyntaxKind Kind,
   case SyntaxKind::AvailabilityLabeledArgument:
   case SyntaxKind::MetatypeType:
   case SyntaxKind::OptionalType:
-  case SyntaxKind::ImplicitlyUnwrappedOptionalType: {
+  case SyntaxKind::ImplicitlyUnwrappedOptionalType:
+  case SyntaxKind::TypeExpr: {
     auto Pair = SyntaxFactory::countChildren(Kind);
     assert(Pair.first == Pair.second);
     createNodeInPlace(Kind, Pair.first, nodeCreateK);

utils/gyb_syntax_support/ExprNodes.py

@@ -351,16 +351,46 @@
                    is_optional=True),
          ]),
 
-    # is TypeName
+    # 'is'
+    # "is" type casting ooperator without operands.
+    # NOTE: This appears only in SequenceExpr.
+    Node('UnresolvedIsExpr', kind='Expr',
+         children=[
+             Child("IsTok", kind='IsToken'),
+         ]),
+
+    # expression is TypeName
+    # NOTE: This won't come directly out of the parser. Rather, it is the
+    # result of "folding" a SequenceExpr based on knowing the precedence
+    # relationships amongst the different infix operators.
     Node('IsExpr', kind='Expr',
          children=[
+             Child("Expression", kind="Expr"),
              Child("IsTok", kind='IsToken'),
              Child("TypeName", kind='Type')
          ]),
 
-    # as TypeName
+    # 'as' ('?'|'!')
+    # "as" type casting ooperator without operands.
+    # NOTE: This appears only in SequenceExpr.
+    Node('UnresolvedAsExpr', kind='Expr',
+         children=[
+             Child("AsTok", kind='AsToken'),
+             Child("QuestionOrExclamationMark", kind='Token',
+                   is_optional=True,
+                   token_choices=[
+                       'PostfixQuestionMarkToken',
+                       'ExclamationMarkToken',
+                   ]),
+         ]),
+
+    # expression as TypeName
+    # NOTE: This won't come directly out of the parser. Rather, it is the
+    # result of "folding" a SequenceExpr based on knowing the precedence
+    # relationships amongst the different infix operators.
     Node('AsExpr', kind='Expr',
          children=[
+             Child("Expression", kind="Expr"),
              Child("AsTok", kind='AsToken'),
              Child("QuestionOrExclamationMark", kind='Token',
                    is_optional=True,

utils/gyb_syntax_support/NodeSerializationCodes.py

@@ -272,6 +272,8 @@
     'InfixOperatorExpr': 268,
     'MoveExpr': 269,
     'UnresolvedTernaryExpr': 270,
+    'UnresolvedIsExpr': 271,
+    'UnresolvedAsExpr': 272,
 }