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 628 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

[Paul Berry, 2017/02/28 20:43:56]

Nit: I would describe this as "A typedef that defines a function type that may
be generic."

[Brian Wilkerson, 2017/03/07 17:20:32]

In the process of shortening the line below I think I motivated the current form
of the comment. Let me know if this isn't sufficient.

[Paul Berry, 2017/03/07 17:56:21]

I still think it's confusing to say "A typedef that defines a generic function
type", when the fact is that the function type it defines may or may not be
generic, depending on whether the user supplied generic function type
parameters.  To me it's as confusing as if we had described a class declaration
as "a declaration that defines a generic class".

I don't understand why we can't just change the text to say "A typedef that
defines a function type that may be generic."  I could also live with "A typedef
expressed using generic function type syntax", since "generic function type
syntax" is a concept which I've learned does not necessarily imply that the
function type is generic.

But in the interest of forward progress, I won't pursue the issue further.

[Brian Wilkerson, 2017/03/07 18:21:40]

Ok, that seems like a better alternative, so I updated the comment.

+   * ```
+   * 'typedef' identifier typeParameters? '=' returnType? 'Function' typeParameters? parameterTypeList ';'

[Paul Berry, 2017/02/28 20:43:56]

Nit: long line.

+   * ```
+   * 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 1521 matching lines @@
   @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 [isGenericFunctionType] is `false`, the return type of the typedef. If
+   * [isGenericFunctionType] is `true`, the function type being defined.

[Brian Wilkerson, 2017/02/28 20:28:49]

Just noticed that this comment is out of date. Will fix it.

    */
   @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;
 }