[fasta][nnbd] Create DartTypes with nullability from parsed types

Parsed types are auxiliary representation of types from the type test
framework in CFE.

Change-Id: Icd7f1aa4d0711d4a83813a8584ac8d1a5826f6c7
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/105422
Reviewed-by: Johnni Winther <johnniwinther@google.com>
Commit-Queue: Dmitry Stefantsov <dmitryas@google.com>

Author: Dmitry Stefantsov

pkg/front_end/test/fasta/types/kernel_type_parser.dart

@@ -161,14 +161,14 @@ class KernelFromParsedType implements Visitor<Node, KernelEnvironment> {
       } else if (kernelArguments.length != typeVariables.length) {
         throw "Expected ${typeVariables.length} type arguments: $node";
       }
-      return new InterfaceType(declaration, kernelArguments);
+      return new InterfaceType(declaration, kernelArguments, node.nullability);
     } else if (declaration is TypeParameter) {
       if (arguments.isNotEmpty) {
         throw "Type variable can't have arguments (${node.name})";
       }
-      return new TypeParameterType(declaration);
+      return new TypeParameterType(declaration, null, node.nullability);
     } else if (declaration is Typedef) {
-      return new TypedefType(declaration, kernelArguments);
+      return new TypedefType(declaration, kernelArguments, node.nullability);
     } else {
       throw "Unhandled ${declaration.runtimeType}";
     }
@@ -263,7 +263,8 @@ class KernelFromParsedType implements Visitor<Node, KernelEnvironment> {
     return new FunctionType(positionalParameters, returnType,
         namedParameters: namedParameters,
         requiredParameterCount: node.arguments.required.length,
-        typeParameters: parameterEnvironment.parameters);
+        typeParameters: parameterEnvironment.parameters,
+        nullability: node.nullability);
   }
 
   VoidType visitVoidType(ParsedVoidType node, KernelEnvironment environment) {
@@ -280,7 +281,7 @@ class KernelFromParsedType implements Visitor<Node, KernelEnvironment> {
     TypeParameterType type =
         node.a.accept<Node, KernelEnvironment>(this, environment);
     DartType bound = node.b.accept<Node, KernelEnvironment>(this, environment);
-    return new TypeParameterType(type.parameter, bound);
+    return new TypeParameterType(type.parameter, bound, type.nullability);
   }
 
   Supertype toSupertype(InterfaceType type) {

pkg/front_end/test/fasta/types/shared_type_tests.dart

@@ -412,5 +412,16 @@ abstract class SubtypeTest<T, E> {
     isSubtype("({int c, int b, int a}) -> void", "({int b, int c}) -> void");
     isSubtype("({int a, int b, int c}) -> void", "({int c}) -> void");
     isSubtype("({int c, int b, int a}) -> void", "({int c}) -> void");
+
+    // Parsing of nullable and legacy types.
+    isSubtype("int?", "int?");
+    isSubtype("int*", "int*");
+    isSubtype("(int) ->? int", "(int) ->? int");
+    isSubtype("(int) ->* int", "(int) ->* int");
+    isSubtype("(int, int*, int?) -> int?", "(int, int*, int?) -> int?");
+    isSubtype("List<int>?", "List<int>?");
+    isSubtype("List<int?>?", "List<int?>?");
+    isSubtype("T & int?", "T & int?", typeParameters: "T extends Object?");
+    isSubtype("T? & int?", "T? & int?", typeParameters: "T extends Object");
   }
 }

pkg/front_end/test/fasta/types/type_parser.dart

@@ -2,6 +2,8 @@
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
+import "package:kernel/ast.dart" show Nullability;
+
 import "package:front_end/src/fasta/scanner.dart" show scanString, Token;
 
 import "package:front_end/src/fasta/parser/type_info_impl.dart"
@@ -16,7 +18,9 @@ class ParsedInterfaceType extends ParsedType {
 
   final List<ParsedType> arguments;
 
-  ParsedInterfaceType(this.name, this.arguments);
+  final Nullability nullability;
+
+  ParsedInterfaceType(this.name, this.arguments, this.nullability);
 
   String toString() {
     StringBuffer sb = new StringBuffer();
@@ -116,7 +120,10 @@ class ParsedFunctionType extends ParsedType {
 
   final ParsedArguments arguments;
 
-  ParsedFunctionType(this.typeVariables, this.returnType, this.arguments);
+  final Nullability nullability;
+
+  ParsedFunctionType(
+      this.typeVariables, this.returnType, this.arguments, this.nullability);
 
   String toString() {
     StringBuffer sb = new StringBuffer();
@@ -260,6 +267,16 @@ class Parser {
     }
   }
 
+  Nullability parseNullability() {
+    Nullability result = Nullability.nonNullable;
+    if (optionalAdvance("?")) {
+      result = Nullability.nullable;
+    } else if (optionalAdvance("*")) {
+      result = Nullability.legacy;
+    }
+    return result;
+  }
+
   ParsedType parseType() {
     if (optional("class")) return parseClass();
     if (optional("typedef")) return parseTypedef();
@@ -269,7 +286,9 @@ class Parser {
       if (optional("(") || optional("<")) {
         type = parseFunctionType();
       } else if (optionalAdvance("void")) {
-        type = new ParsedInterfaceType("void", <ParsedType>[]);
+        type = new ParsedInterfaceType(
+            "void", <ParsedType>[], Nullability.nullable);
+        optionalAdvance("?");
       } else {
         String name = parseName();
         List<ParsedType> arguments = <ParsedType>[];
@@ -283,7 +302,8 @@ class Parser {
           peek = splitCloser(peek) ?? peek;
           expect(">");
         }
-        type = new ParsedInterfaceType(name, arguments);
+        Nullability nullability = parseNullability();
+        type = new ParsedInterfaceType(name, arguments, nullability);
       }
       if (result == null) {
         result = type;
@@ -304,8 +324,10 @@ class Parser {
     ParsedArguments arguments = parseArguments();
     expect("-");
     expect(">");
+    Nullability nullability = parseNullability();
     ParsedType returnType = parseReturnType();
-    return new ParsedFunctionType(typeVariables, returnType, arguments);
+    return new ParsedFunctionType(
+        typeVariables, returnType, arguments, nullability);
   }
 
   String parseName() {