Drop implicit types from summaries.

pkg/analyzer/tool/summary/idl.dart

 // Copyright (c) 2015, 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.
 
 /**
  * This file is an "idl" style description of the summary format.  It is not
  * executed directly; instead it is parsed and transformed into code that
  * implements the summary format.
  *
  * The code generation process introduces the following non-typical semantics:
@@ skipping 569 matching lines @@
    * `a` is a prefix name and `b` is a class name.
    *
    * TODO(paulberry): figure out how to resolve this ambiguity in the
    * "prelinked" part of the summary.
    */
   invokeConstructor,
 
   /**
    * Pop the top n values from the stack (where n is obtained from
    * [UnlinkedConst.ints]), place them in a [List], and push the result back
+   * onto the stack.  The type parameter for the [List] is implicitly `dynamic`.
+   */
+  makeUntypedList,
+
+  /**
+   * Pop the top 2*n values from the stack (where n is obtained from
+   * [UnlinkedConst.ints]), interpret them as key/value pairs, place them in a
+   * [Map], and push the result back onto the stack.  The two type parameters
+   * for the [Map] are implicitly `dynamic`.
+   */
+  makeUntypedMap,
+
+  /**
+   * Pop the top n values from the stack (where n is obtained from
+   * [UnlinkedConst.ints]), place them in a [List], and push the result back
    * onto the stack.  The type parameter for the [List] is obtained from
    * [UnlinkedConst.references].
    */
-  makeList,
+  makeTypedList,
 
   /**
    * Pop the top 2*n values from the stack (where n is obtained from
    * [UnlinkedConst.ints]), interpret them as key/value pairs, place them in a
    * [Map], and push the result back onto the stack.  The two type parameters for
    * the [Map] are obtained from [UnlinkedConst.references].
    */
-  makeMap,
+  makeTypedMap,
 
   /**
    * Pop the top 2 values from the stack, pass them to the predefined Dart
    * function `identical`, and push the result back onto the stack.
    */
   identical,
 
   /**
    * Pop the top 2 values from the stack, evaluate `v1 == v2`, and push the
    * result back onto the stack.
@@ skipping 240 matching lines @@
   UnlinkedDocumentationComment documentationComment;
 
   /**
    * Type parameters of the executable, if any.  Empty if support for generic
    * method syntax is disabled.
    */
   List<UnlinkedTypeParam> typeParameters;
 
   /**
    * Declared return type of the executable.  Absent if the executable is a
-   * constructor.  Note that when strong mode is enabled, the actual return
-   * type may be different due to type inference.
+   * constructor or the return type is implicit.
    */
   EntityRef returnType;
 
   /**
    * Parameters of the executable, if any.  Note that getters have no
    * parameters (hence this will be the empty list), and setters have a single
    * parameter.
    */
   List<UnlinkedParam> parameters;
 
@@ skipping 21 matching lines @@
    * Indicates whether the executable is declared using the `const` keyword.
    */
   bool isConst;
 
   /**
    * Indicates whether the executable is declared using the `factory` keyword.
    */
   bool isFactory;
 
   /**
-   * Indicates whether the executable lacks an explicit return type
-   * declaration.  False for constructors and setters.
-   */
-  bool hasImplicitReturnType;
-
-  /**
    * Indicates whether the executable is declared using the `external` keyword.
    */
   bool isExternal;
 }
 
 /**
  * Enum used to indicate the kind of an executable.
  */
 enum UnlinkedExecutableKind {
   /**
@@ skipping 130 matching lines @@
   String name;
 
   /**
    * Offset of the parameter name relative to the beginning of the file.
    */
   @informative
   int nameOffset;
 
   /**
    * If [isFunctionTyped] is `true`, the declared return type.  If
-   * [isFunctionTyped] is `false`, the declared type.
+   * [isFunctionTyped] is `false`, the declared type.  Absent if the type is
+   * implicit.
    */
   EntityRef type;
 
   /**
    * If [isFunctionTyped] is `true`, the parameters of the function type.
    */
   List<UnlinkedParam> parameters;
 
   /**
    * Kind of the parameter.
    */
   UnlinkedParamKind kind;
 
   /**
    * Indicates whether this is a function-typed parameter.
    */
   bool isFunctionTyped;
 
   /**
    * Indicates whether this is an initializing formal parameter (i.e. it is
    * declared using `this.` syntax).
    */
   bool isInitializingFormal;
-
-  /**
-   * Indicates whether this parameter lacks an explicit type declaration.
-   * Always false for a function-typed parameter.
-   */
-  bool hasImplicitType;
 }
 
 /**
  * Enum used to indicate the kind of a parameter.
  */
 enum UnlinkedParamKind {
   /**
    * Parameter is required.
    */
   required,
@@ skipping 272 matching lines @@
   int nameOffset;
 
   /**
    * Documentation comment for the variable, or `null` if there is no
    * documentation comment.
    */
   @informative
   UnlinkedDocumentationComment documentationComment;
 
   /**
-   * Declared type of the variable.  Note that when strong mode is enabled, the
-   * actual type of the variable may be different due to type inference.
+   * Declared type of the variable.  Absent if the type is implicit.
    */
   EntityRef type;
 
   /**
    * If [isConst] is true, and the variable has an initializer, the constant
    * expression in the initializer.
    */
   UnlinkedConst constExpr;
 
   /**
    * Indicates whether the variable is declared using the `static` keyword.
    *
    * Note that for top level variables, this flag is false, since they are not
    * declared using the `static` keyword (even though they are considered
    * static for semantic purposes).
    */
   bool isStatic;
 
   /**
    * Indicates whether the variable is declared using the `final` keyword.
    */
   bool isFinal;
 
   /**
    * Indicates whether the variable is declared using the `const` keyword.
    */
   bool isConst;
 
   /**
-   * Indicates whether this variable lacks an explicit type declaration.
-   */
-  bool hasImplicitType;
-
-  /**
    * If this variable is propagable, nonzero slot id identifying which entry in
    * [LinkedLibrary.types] contains the propagated type for this variable.  If
    * there is no matching entry in [LinkedLibrary.types], then this variable's
    * propagated type is the same as its declared type.
    *
    * Non-propagable variables have a [propagatedTypeSlot] of zero.
    */
   int propagatedTypeSlot;
 }