Add support for parsing simple nullable types

... as part of adding NNBD as outlined in
dart-lang/language#110

This only supports parsing simple nullable types
such as int? and List<int>? while subsequent CLs
will add support for parsing more complex types.

Change-Id: I144858946cb115755af437299899c2631105bf8c
Reviewed-on: https://dart-review.googlesource.com/c/87501
Reviewed-by: Brian Wilkerson <[email protected]>
Commit-Queue: Dan Rubel <[email protected]>

Author: danrubel

pkg/front_end/lib/src/fasta/parser/parser.dart

@@ -4489,11 +4489,7 @@ class Parser {
     Token name = beforeName.next;
     if (name.isIdentifier) {
       TypeParamOrArgInfo typeParam = computeTypeParamOrArg(name);
-      Token next = name;
-      if (typeParam != noTypeParamOrArg) {
-        next = typeParam.skip(next);
-      }
-      next = next.next;
+      Token next = typeParam.skip(name).next;
       if (optional('(', next)) {
         if (looksLikeFunctionBody(next.endGroup.next)) {
           return parseFunctionLiteral(
@@ -4873,8 +4869,10 @@ class Parser {
     if (optional('!', token.next)) {
       not = token = token.next;
     }
-    // Ignore trailing `?` if there is one as it may be part of an expression
-    TypeInfo typeInfo = computeType(token, true).asNonNullableType();
+    TypeInfo typeInfo = computeType(token, true);
+    if (typeInfo.isConditionalExpressionStart(token, this)) {
+      typeInfo = typeInfo.asNonNullable;
+    }
     token = typeInfo.ensureTypeNotVoid(token, this);
     listener.handleIsOperator(operator, not);
     return skipChainedAsIsOperators(token);
@@ -4888,8 +4886,10 @@ class Parser {
   Token parseAsOperatorRest(Token token) {
     Token operator = token = token.next;
     assert(optional('as', operator));
-    // Ignore trailing `?` if there is one as it may be part of an expression
-    TypeInfo typeInfo = computeType(token, true).asNonNullableType();
+    TypeInfo typeInfo = computeType(token, true);
+    if (typeInfo.isConditionalExpressionStart(token, this)) {
+      typeInfo = typeInfo.asNonNullable;
+    }
     token = typeInfo.ensureTypeNotVoid(token, this);
     listener.handleAsOperator(operator);
     return skipChainedAsIsOperators(token);
@@ -4908,7 +4908,11 @@ class Parser {
       if (optional('!', next.next)) {
         next = next.next;
       }
-      token = computeType(next, true).skipType(next);
+      TypeInfo typeInfo = computeType(next, true);
+      if (typeInfo.isConditionalExpressionStart(next, this)) {
+        typeInfo = typeInfo.asNonNullable;
+      }
+      token = typeInfo.skipType(next);
       next = token.next;
       value = next.stringValue;
     }
@@ -5029,6 +5033,10 @@ class Parser {
       TypeInfo typeInfo,
       bool onlyParseVariableDeclarationStart = false]) {
     typeInfo ??= computeType(beforeType, false);
+    if (typeInfo.isConditionalExpressionStart(beforeType, this)) {
+      typeInfo = noType;
+    }
+
     Token token = typeInfo.skipType(beforeType);
     Token next = token.next;
 

pkg/front_end/lib/src/fasta/parser/type_info.dart

@@ -19,12 +19,12 @@ import 'util.dart' show isOneOf, optional;
 abstract class TypeInfo {
   /// Return type info representing the receiver without the trailing `?`
   /// or the receiver if the receiver does not represent a nullable type.
-  TypeInfo asNonNullableType();
+  TypeInfo get asNonNullable;
 
   /// Return `true` if the tokens comprising the type represented by the
   /// receiver could be interpreted as a valid standalone expression.
-  /// For example, `A` or `A.b` could be interpreted as a type references
-  /// or as expressions, while `A<T>` only looks like a type reference.
+  /// For example, `A` or `A.b` could be interpreted as type references
+  /// or expressions, while `A<T>` only looks like a type reference.
   bool get couldBeExpression;
 
   /// Call this function when the token after [token] must be a type (not void).
@@ -41,6 +41,13 @@ abstract class TypeInfo {
   /// in valid code or during recovery.
   Token ensureTypeOrVoid(Token token, Parser parser);
 
+  /// Return `true` if the tokens comprising the type represented by the
+  /// receiver are the start of a conditional expression.
+  /// For example, `A?` or `A.b?` could be the start of a conditional expression
+  /// and require arbitrary look ahead to determine if it is,
+  /// while `A<T>?` cannot be the start of a conditional expression.
+  bool isConditionalExpressionStart(Token token, Parser parser);
+
   /// Call this function to parse an optional type (not void) after [token].
   /// This function will call the appropriate event methods on the [Parser]'s
   /// listener to handle the type. This may modify the token stream
@@ -199,13 +206,19 @@ TypeInfo computeType(final Token token, bool required,
       // We've seen identifier `<` identifier `>`
       next = typeParamOrArg.skip(next).next;
       if (!isGeneralizedFunctionType(next)) {
-        if (required || looksLikeName(next)) {
-          // identifier `<` identifier `>` identifier
-          return typeParamOrArg.typeInfo;
+        if (optional('?', next) && typeParamOrArg == simpleTypeArgument1) {
+          if (required || looksLikeName(next.next)) {
+            // identifier `<` identifier `>` `?` identifier
+            return simpleNullableTypeWith1Argument;
+          }
         } else {
-          // identifier `<` identifier `>` non-identifier
-          return noType;
+          if (required || looksLikeName(next)) {
+            // identifier `<` identifier `>` identifier
+            return typeParamOrArg.typeInfo;
+          }
         }
+        // identifier `<` identifier `>` non-identifier
+        return noType;
       }
     }
     // TODO(danrubel): Consider adding a const for
@@ -255,7 +268,21 @@ TypeInfo computeType(final Token token, bool required,
         .computeIdentifierGFT(required);
   }
 
-  if (required || looksLikeName(next)) {
+  if (optional('?', next)) {
+    if (required) {
+      // identifier `?`
+      return simpleNullableType;
+    } else {
+      next = next.next;
+      if (isGeneralizedFunctionType(next)) {
+        // identifier `?` Function `(`
+        return simpleNullableType;
+      } else if (looksLikeName(next)) {
+        // identifier `?` identifier `=`
+        return simpleNullableType;
+      }
+    }
+  } else if (required || looksLikeName(next)) {
     // identifier identifier
     return simpleType;
   }

pkg/front_end/lib/src/fasta/parser/type_info_impl.dart

@@ -38,6 +38,10 @@ import 'util.dart'
 /// when there is a single identifier as the type reference.
 const TypeInfo simpleType = const SimpleType();
 
+/// [SimpleNullableType] is a specialized [TypeInfo] returned by [computeType]
+/// when there is a single identifier followed by `?` as the type reference.
+const TypeInfo simpleNullableType = const SimpleNullableType();
+
 /// [PrefixedType] is a specialized [TypeInfo] returned by [computeType]
 /// when the type reference is of the form: identifier `.` identifier.
 const TypeInfo prefixedType = const PrefixedType();
@@ -60,6 +64,12 @@ const TypeInfo simpleTypeWith1ArgumentGtEq =
 const TypeInfo simpleTypeWith1ArgumentGtGt =
     const SimpleTypeWith1Argument(simpleTypeArgument1GtGt);
 
+/// [SimpleNullableTypeWith1Argument] is a specialized [TypeInfo] returned by
+/// [computeType] when the type reference is of the form:
+/// identifier `<` identifier `>` `?`.
+const TypeInfo simpleNullableTypeWith1Argument =
+    const SimpleNullableTypeWith1Argument();
+
 /// [SimpleTypeArgument1] is a specialized [TypeParamOrArgInfo] returned by
 /// [computeTypeParamOrArg] when the type reference is of the form:
 /// `<` identifier `>`.
@@ -82,10 +92,10 @@ class NoType implements TypeInfo {
   const NoType();
 
   @override
-  bool get couldBeExpression => false;
+  TypeInfo get asNonNullable => this;
 
   @override
-  TypeInfo asNonNullableType() => this;
+  bool get couldBeExpression => false;
 
   @override
   Token ensureTypeNotVoid(Token token, Parser parser) {
@@ -99,6 +109,9 @@ class NoType implements TypeInfo {
   Token ensureTypeOrVoid(Token token, Parser parser) =>
       ensureTypeNotVoid(token, parser);
 
+  @override
+  bool isConditionalExpressionStart(Token token, Parser parser) => false;
+
   @override
   Token parseTypeNotVoid(Token token, Parser parser) =>
       parseType(token, parser);
@@ -120,10 +133,10 @@ class PrefixedType implements TypeInfo {
   const PrefixedType();
 
   @override
-  bool get couldBeExpression => true;
+  TypeInfo get asNonNullable => this;
 
   @override
-  TypeInfo asNonNullableType() => this;
+  bool get couldBeExpression => true;
 
   @override
   Token ensureTypeNotVoid(Token token, Parser parser) =>
@@ -133,6 +146,9 @@ class PrefixedType implements TypeInfo {
   Token ensureTypeOrVoid(Token token, Parser parser) =>
       parseType(token, parser);
 
+  @override
+  bool isConditionalExpressionStart(Token token, Parser parser) => false;
+
   @override
   Token parseTypeNotVoid(Token token, Parser parser) =>
       parseType(token, parser);
@@ -164,17 +180,44 @@ class PrefixedType implements TypeInfo {
   }
 }
 
+/// See documentation on the [simpleNullableTypeWith1Argument] const.
+class SimpleNullableTypeWith1Argument extends SimpleTypeWith1Argument {
+  const SimpleNullableTypeWith1Argument() : super(simpleTypeArgument1);
+
+  @override
+  TypeInfo get asNonNullable => simpleTypeWith1Argument;
+
+  @override
+  bool isConditionalExpressionStart(Token token, Parser parser) =>
+      isConditionalThenExpression(skipType(token), parser);
+
+  @override
+  Token parseTypeRest(Token start, Token token, Parser parser) {
+    token = token.next;
+    assert(optional('?', token));
+    parser.listener.handleType(start, token);
+    return token;
+  }
+
+  @override
+  Token skipType(Token token) {
+    token = super.skipType(token).next;
+    assert(optional('?', token));
+    return token;
+  }
+}
+
 /// See documentation on the [simpleTypeWith1Argument] const.
 class SimpleTypeWith1Argument implements TypeInfo {
   final TypeParamOrArgInfo typeArg;
 
   const SimpleTypeWith1Argument(this.typeArg);
 
   @override
-  bool get couldBeExpression => false;
+  TypeInfo get asNonNullable => this;
 
   @override
-  TypeInfo asNonNullableType() => this;
+  bool get couldBeExpression => false;
 
   @override
   Token ensureTypeNotVoid(Token token, Parser parser) =>
@@ -184,6 +227,9 @@ class SimpleTypeWith1Argument implements TypeInfo {
   Token ensureTypeOrVoid(Token token, Parser parser) =>
       parseType(token, parser);
 
+  @override
+  bool isConditionalExpressionStart(Token token, Parser parser) => false;
+
   @override
   Token parseTypeNotVoid(Token token, Parser parser) =>
       parseType(token, parser);
@@ -210,15 +256,40 @@ class SimpleTypeWith1Argument implements TypeInfo {
   }
 }
 
+/// See documentation on the [simpleNullableType] const.
+class SimpleNullableType extends SimpleType {
+  const SimpleNullableType();
+
+  @override
+  TypeInfo get asNonNullable => simpleType;
+
+  @override
+  bool isConditionalExpressionStart(Token token, Parser parser) =>
+      isConditionalThenExpression(skipType(token), parser);
+
+  @override
+  Token parseTypeRest(Token start, Parser parser) {
+    Token token = start.next;
+    assert(optional('?', token));
+    parser.listener.handleType(start, token);
+    return token;
+  }
+
+  @override
+  Token skipType(Token token) {
+    return token.next.next;
+  }
+}
+
 /// See documentation on the [simpleType] const.
 class SimpleType implements TypeInfo {
   const SimpleType();
 
   @override
-  bool get couldBeExpression => true;
+  TypeInfo get asNonNullable => this;
 
   @override
-  TypeInfo asNonNullableType() => this;
+  bool get couldBeExpression => true;
 
   @override
   Token ensureTypeNotVoid(Token token, Parser parser) =>
@@ -228,6 +299,9 @@ class SimpleType implements TypeInfo {
   Token ensureTypeOrVoid(Token token, Parser parser) =>
       parseType(token, parser);
 
+  @override
+  bool isConditionalExpressionStart(Token token, Parser parser) => false;
+
   @override
   Token parseTypeNotVoid(Token token, Parser parser) =>
       parseType(token, parser);
@@ -257,10 +331,10 @@ class VoidType implements TypeInfo {
   const VoidType();
 
   @override
-  bool get couldBeExpression => false;
+  TypeInfo get asNonNullable => this;
 
   @override
-  TypeInfo asNonNullableType() => this;
+  bool get couldBeExpression => false;
 
   @override
   Token ensureTypeNotVoid(Token token, Parser parser) {
@@ -273,6 +347,9 @@ class VoidType implements TypeInfo {
   Token ensureTypeOrVoid(Token token, Parser parser) =>
       parseType(token, parser);
 
+  @override
+  bool isConditionalExpressionStart(Token token, Parser parser) => false;
+
   @override
   Token parseTypeNotVoid(Token token, Parser parser) =>
       ensureTypeNotVoid(token, parser);
@@ -337,13 +414,13 @@ class ComplexTypeInfo implements TypeInfo {
       : this.start = beforeStart.next;
 
   @override
-  bool get couldBeExpression => false;
-
-  @override
-  TypeInfo asNonNullableType() {
+  TypeInfo get asNonNullable {
     return this;
   }
 
+  @override
+  bool get couldBeExpression => false;
+
   @override
   Token ensureTypeNotVoid(Token token, Parser parser) =>
       parseType(token, parser);
@@ -352,6 +429,12 @@ class ComplexTypeInfo implements TypeInfo {
   Token ensureTypeOrVoid(Token token, Parser parser) =>
       parseType(token, parser);
 
+  @override
+  bool isConditionalExpressionStart(Token token, Parser parser) {
+    //return isConditionalThenExpression(token.next.next, parser);
+    return false;
+  }
+
   @override
   Token parseTypeNotVoid(Token token, Parser parser) =>
       parseType(token, parser);
@@ -1061,3 +1144,16 @@ Token splitCloser(Token closer) {
   }
   return null;
 }
+
+/// Return `true` if the tokens after [token]
+/// represent a valid expression followed by a `:`.
+bool isConditionalThenExpression(Token token, Parser parser) {
+  // TODO(danrubel): Consider adding checks for simple situations
+  // before resorting to heavy weight lookahead.
+
+  final originalListener = parser.listener;
+  parser.listener = new ForwardingListener();
+  token = parser.parseExpression(token);
+  parser.listener = originalListener;
+  return optional(':', token.next);
+}