Initial support for the NNBD proposal

pkg/analyzer/lib/dart/ast/ast.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // 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.
 
 /**
  * Defines the AST model. The AST (Abstract Syntax Tree) model describes the
  * syntactic (as opposed to semantic) structure of Dart code. The semantic
  * structure of the code is modeled by the
  * [element model](../element/element.dart).
  *
@@ skipping 4274 matching lines @@
    * [comment] and [metadata] can be `null` if the parameter does not have the
    * corresponding attribute. The [returnType] can be `null` if no return type
    * was specified.
    */
   factory FunctionTypedFormalParameter(
           Comment comment,
           List<Annotation> metadata,
           TypeName returnType,
           SimpleIdentifier identifier,
           TypeParameterList typeParameters,
-          FormalParameterList parameters) =>
+          FormalParameterList parameters,
+          {Token question: null}) =>
       new FunctionTypedFormalParameterImpl(comment, metadata, returnType,
-          identifier, typeParameters, parameters);
+          identifier, typeParameters, parameters, question);
 
   /**
    * Return the parameters of the function-typed parameter.
    */
   FormalParameterList get parameters;
 
   /**
    * Set the parameters of the function-typed parameter to the given
    * [parameters].
    */
   void set parameters(FormalParameterList parameters);
 
   /**
+   * Return the question mark marking this as a nullable type, or `null` if
+   * the type is non-nullable.
+   */
+  Token get question;
+
+  /**
+   * Return the question mark marking this as a nullable type to the given
+   * [question].
+   */
+  void set question(Token question);
+
+  /**
    * Return the return type of the function, or `null` if the function does not
    * have a return type.
    */
   TypeName get returnType;
 
   /**
    * Set the return type of the function to the given [type].
    */
   void set returnType(TypeName type);
 
@@ skipping 3396 matching lines @@
  *    typeName ::=
  *        [Identifier] typeArguments?
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class TypeName extends AstNode {
   /**
    * Initialize a newly created type name. The [typeArguments] can be `null` if
    * there are no type arguments.
    */
-  factory TypeName(Identifier name, TypeArgumentList typeArguments) =>
-      new TypeNameImpl(name, typeArguments);
+  factory TypeName(Identifier name, TypeArgumentList typeArguments,
+          {Token question: null}) =>
+      new TypeNameImpl(name, typeArguments, question);
 
   /**
    * Return `true` if this type is a deferred type.
    *
    * 15.1 Static Types: A type <i>T</i> is deferred iff it is of the form
    * </i>p.T</i> where <i>p</i> is a deferred prefix.
    */
   bool get isDeferred;
 
   /**
    * Return the name of the type.
    */
   Identifier get name;
 
   /**
    * Set the name of the type to the given [identifier].
    */
   void set name(Identifier identifier);
 
   /**
+   * Return the question mark marking this as a nullable type, or `null` if
+   * the type is non-nullable.
+   */
+  Token get question;
+
+  /**
+   * Return the question mark marking this as a nullable type to the given
+   * [question].
+   */
+  void set question(Token question);
+
+  /**
    * Return the type being named, or `null` if the AST structure has not been
    * resolved.
    */
   DartType get type;
 
   /**
    * Set the type being named to the given [type].
    */
   void set type(DartType type);
 
@@ skipping 511 matching lines @@
   /**
    * Return the 'yield' keyword.
    */
   Token get yieldKeyword;
 
   /**
    * Return the 'yield' keyword to the given [token].
    */
   void set yieldKeyword(Token token);
 }