First cut at idl changes

pkg/analyzer/lib/src/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
  * contains abstract classes which declare the interface for reading data from
  * summaries.  It is parsed and transformed into code that implements the
  * summary format.
  *
@@ skipping 338 matching lines @@
   int get length;
 
   /**
    * Offset of the element code relative to the beginning of the file.
    */
   @Id(0)
   int get offset;
 }
 
 /**
- * Summary information about a reference to a an entity such as a type, top
- * level executable, or executable within a class.
+ * Summary information about a reference to an entity such as a type, top level
+ * executable, or executable within a class.
  */
 abstract class EntityRef extends base.SummaryClass {
   /**
    * If this is a reference to a function type implicitly defined by a
    * function-typed parameter, a list of zero-based indices indicating the path
    * from the entity referred to by [reference] to the appropriate type
    * parameter.  Otherwise the empty list.
    *
    * If there are N indices in this list, then the entity being referred to is
    * the function type implicitly defined by a function-typed parameter of a
@@ skipping 70 matching lines @@
    */
   @Id(5)
   EntityRef get syntheticReturnType;
 
   /**
    * If this is an instantiation of a generic type or generic executable, the
    * type arguments used to instantiate it (if any).
    */
   @Id(1)
   List<EntityRef> get typeArguments;
+
+  /**
+   * If this is a function type, the type parameters defined for the function
+   * type (if any).
+   */
+  @Id(7)
+  List<UnlinkedTypeParam> get typeParameters;
 }
 
 /**
  * Enum used to indicate the kind of a name in index.
  */
 enum IndexNameKind {
   /**
    * A top-level element.
    */
   topLevel,
@@ skipping 498 matching lines @@
 
   /**
    * Each item of this list corresponds to a unique referenced element.  It is
    * the kind of the synthetic element.
    */
   @Id(5)
   List<IndexSyntheticElementKind> get elementKinds;
 
   /**
    * Each item of this list corresponds to a unique referenced element.  It is
-   * the identifier of the class member element name, or `null` if the element is
-   * a top-level element.  The list is sorted in ascending order, so that the
+   * the identifier of the class member element name, or `null` if the element
+   * is a top-level element.  The list is sorted in ascending order, so that the
    * client can quickly check whether an element is referenced in this
    * [PackageIndex].
    */
   @Id(7)
   List<int> get elementNameClassMemberIds;
 
   /**
    * Each item of this list corresponds to a unique referenced element.  It is
    * the identifier of the named parameter name, or `null` if the element is not
    * a named parameter.  The list is sorted in ascending order, so that the
@@ skipping 108 matching lines @@
    */
   prefix,
 
   /**
    * The entity being referred to does not exist.
    */
   unresolved
 }
 
 /**
+ * Enum used to indicate the style of a typedef.
+ */
+enum TypedefStyle {
+  /**
+   * A typedef that defines a non-generic function type. The syntax is
+   * ```
+   * 'typedef' returnType? identifier typeParameters? formalParameterList ';'
+   * ```
+   * The typedef can have type parameters associated with it, but the function
+   * type that results from applying type arguments does not.
+   */
+  functionType,
+
+  /**
+   * A typedef that defines a generic function type. The syntax is
+   * ```
+   * typeAlias ::=
+   *     'typedef' identifier typeParameters? '=' genericFunctionType ';'
+   * genericFunctionType ::=
+   *     returnType? 'Function' typeParameters? parameterTypeList
+   * ```
+   * Both the typedef itself and the function type that results from applying
+   * type arguments can have type parameters.
+   */
+  genericFunctionType
+}
+
+/**
  * Index information about a unit in a [PackageIndex].
  */
 abstract class UnitIndex extends base.SummaryClass {
   /**
    * Each item of this list is the kind of an element defined in this unit.
    */
   @Id(6)
   List<IndexNameKind> get definedNameKinds;
 
   /**
@@ skipping 1011 matching lines @@
    * Pop the top n values from the stack (where n is obtained from
    * [UnlinkedExpr.ints]), place them in a [List], and push the result back
    * onto the stack.  The type parameter for the [List] is obtained from
    * [UnlinkedExpr.references].
    */
   makeTypedList,
 
   /**
    * Pop the top 2*n values from the stack (where n is obtained from
    * [UnlinkedExpr.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 [UnlinkedExpr.references].
+   * [Map], and push the result back onto the stack.  The two type parameters
+   * for the [Map] are obtained from [UnlinkedExpr.references].
    */
   makeTypedMap,
 
   /**
    * Pop the top 2 values from the stack, evaluate `v1 == v2`, and push the
    * result back onto the stack.
    */
   equal,
 
   /**
@@ skipping 469 matching lines @@
    * unique within this compilation unit.  If this id is found in
    * [LinkedUnit.parametersInheritingCovariant], then this parameter inherits
    * `@covariant` behavior from a base class.
    *
    * Otherwise, zero.
    */
   @Id(14)
   int get inheritsCovariantSlot;
 
   /**
-   * The synthetic initializer function of the parameter.  Absent if the variable
-   * does not have an initializer.
+   * The synthetic initializer function of the parameter.  Absent if the
+   * variable does not have an initializer.
    */
   @Id(12)
   UnlinkedExecutable get initializer;
 
   /**
    * Indicates whether this parameter is explicitly marked as being covariant.
    */
   @Id(15)
   bool get isExplicitlyCovariant;
 
   /**
    * Indicates whether the parameter is declared using the `final` keyword.
    */
   @Id(16)
   bool get isFinal;
 
   /**
-   * Indicates whether this is a function-typed parameter.
+   * Indicates whether this is a function-typed parameter. A parameter is
+   * function-typed if the declaration of the parameter has explicit formal
+   * parameters
+   * ```
+   * int functionTyped(int p)
+   * ```
+   * but is not function-typed if it does not, even if the type of the parameter
+   * is a function type.
    */
   @Id(5)
   bool get isFunctionTyped;
 
   /**
    * Indicates whether this is an initializing formal parameter (i.e. it is
    * declared using `this.` syntax).
    */
   @Id(6)
   bool get isInitializingFormal;
@@ skipping 228 matching lines @@
   @Id(1)
   int get nameOffset;
 
   /**
    * Parameters of the executable, if any.
    */
   @Id(3)
   List<UnlinkedParam> get parameters;
 
   /**
-   * Return type of the typedef.
+   * If [style] is [TypedefStyle.functionType], the return type of the typedef.
+   * If [style] is [TypedefStyle.genericFunctionType], the function type being
+   * defined.
    */
   @Id(2)
   EntityRef get returnType;
 
   /**
+   * The style of the typedef.
+   */
+  @Id(8)
+  TypedefStyle get style;
+
+  /**
    * Type parameters of the typedef, if any.
    */
   @Id(5)
   List<UnlinkedTypeParam> get typeParameters;
 }
 
 /**
  * Unlinked summary information about a type parameter declaration.
  */
 abstract class UnlinkedTypeParam extends base.SummaryClass {
@@ skipping 289 matching lines @@
   @Id(11)
   int get visibleLength;
 
   /**
    * If a local variable, the beginning of the visible range; zero otherwise.
    */
   @informative
   @Id(12)
   int get visibleOffset;
 }