Replace flags in summary IDL with enums and booleans.

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:
  * - Fields of type List are never null, and have a default value of the empty
  *   list.
  * - Fields of type int are never null, and have a default value of zero.
  * - Fields of type String are never null, and have a default value of ''.
+ * - Fields of type bool are never null, and have a default value of false.
+ * - Fields whose type is an enum are never null, and have a default value of
+ *   the first value declared in the enum.
  *
  * Terminology used in this document:
  * - "Unlinked" refers to information that can be determined from reading the
  *   .dart file for the library itself (including all parts) and no other
  *   files.
  * - "Prelinked" refers to information that can be determined from reading the
  *   unlinked information for the library itself and the unlinked information
  *   for all direct imports (plus the transitive closure of exports reachable
  *   from those direct imports).
  * - "Linked" refers to information that can be determined only from reading
@@ skipping 22 matching lines @@
  * Annotation describing information which is not part of the public API to a
  * library; in other words, if this information (or any information it refers
  * to) changes, libraries outside this one are unaffected.
  *
  * TODO(paulberry): currently the summary format does not contain private
  * information.
  */
 const private = null;
 
 /**
- * Annotation used to mark possible values of a "flags" field.  These will be
- * transformed into static constants.
- */
-class Flag {
-  final String name;
-  final int value;
-  final String comment;
-
-  const Flag(this.name, this.value, this.comment);
-}
-
-/**
  * Information about a dependency that exists between one library and another
  * due to an "import" declaration.
  */
 class PrelinkedDependency {
   /**
    * The relative URI used to import one library from the other.
    */
   String uri;
 }
 
@@ skipping 27 matching lines @@
   List<int> importDependencies;
 
   /**
    * For each reference in [UnlinkedLibrary.references], information about how
    * that reference is resolved.
    */
   List<PrelinkedReference> references;
 }
 
 /**
+ * Enum used to indicate the kind of entity referred to by a
+ * [PrelinkedReference].
+ */
+enum PrelinkedReferenceKind {
+  /**
+   * The entity is a class or enum.
+   */
+  classOrEnum,
+
+  /**
+   * The entity is a typedef.
+   */
+  typedef,
+
+  /**
+   * The entity is a variable or executable.
+   */
+  other,
+
+  /**
+   * The entity being referred to does not exist.
+   */
+  unresolved
+}
+
+/**
  * Information about the resolution of an [UnlinkedReference].
  */
 class PrelinkedReference {
   /**
    * Index into [UnlinkedLibrary.dependencies] indicating which imported library
    * declares the entity being referred to.
    */
   int dependency;
 
-  @Flag('CLASS', 0,
-      'Indicates that the thing being referred to is a class or enum')
-  @Flag('TYPEDEF', 1, 'Indicates that the thing being referred to is a typedef')
-  @Flag('OTHER', 2,
-      'Indicates that the thing being referred to is a variable or executable')
-  @Flag('UNRESOLVED', 3,
-      'Indicates that the thing being referred to was not found')
-  int flags;
+  /**
+   * The kind of the entity being referred to.
+   */
+  PrelinkedReferenceKind kind;
 }
 
 /**
  * Unlinked summary information about a class declaration.
  */
 class UnlinkedClass {
   /**
    * Name of the class.
    */
   String name;
@@ skipping 30 matching lines @@
   /**
    * Field declarations contained in the class.
    */
   List<UnlinkedVariable> fields;
 
   /**
    * Executable objects (methods, getters, and setters) contained in the class.
    */
   List<UnlinkedExecutable> executables;
 
-  @Flag(
-      'ABSTRACT', 1, 'Set if the class is declared with the `abstract` keyword')
-  @Flag('MIXIN_APP', 2,
-      'Set if the class is declared using mixin appliation syntax')
-  int flags;
+  /**
+   * Indicates whether the class is declared with the `abstract` keyword.
+   */
+  bool isAbstract;
+
+  /**
+   * Indicates whether the class is declared using mixin application syntax.
+   */
+  bool isMixinApplication;
 }
 
 /**
  * Unlinked summary information about a `show` or `hide` combinator in an
  * import or export declaration.
  */
 class UnlinkedCombinator {
   /**
    * List of names which are shown.  Empty if this is a `hide` combinator.
    */
@@ skipping 32 matching lines @@
  * declaration.
  */
 class UnlinkedEnumValue {
   /**
    * Name of the enumerated value.
    */
   String name;
 }
 
 /**
+ * Enum used to indicate the kind of an executable.
+ */
+enum UnlinkedExecutableKind {
+  /**
+   * Executable is a function or method.
+   */
+  functionOrMethod,
+
+  /**
+   * Executable is a getter.
+   */
+  getter,
+
+  /**
+   * Executable is a setter.
+   */
+  setter,
+
+  /**
+   * Executable is a constructor.
+   */
+  constructor
+}
+
+/**
  * Unlinked summary information about a function, method, getter, or setter
  * declaration.
  */
 class UnlinkedExecutable {
   /**
    * Name of the executable.  For setters, this includes the trailing "=".  For
    * named constructors, this excludes the class name and excludes the ".".
    * For unnamed constructors, this is the empty string.
    */
   String name;
@@ skipping 19 matching lines @@
    */
   UnlinkedTypeRef 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;
 
-  @Flag('FUNCTION', 0,
-      'Indicates that the declaration is for a function or method')
-  @Flag('GETTER', 1, 'Indicates that the declaration is for a getter')
-  @Flag('SETTER', 2, 'Indicates that the declaration is for a setter')
-  @Flag('CONSTRUCTOR', 3, 'Indicates that the declaration is for a constructor')
-  @Flag('ABSTRACT', 4, 'Set if the declaration lacks a function body')
-  @Flag('STATIC', 8, 'Set if the declaration includes the `static` keyword')
-  @Flag('CONST', 16,
-      'Set if the declaration includes the `const` keyword (constructors only)')
-  @Flag('FACTORY', 32,
-      'Set if the declaration includes the `factory` keyword (constructors only)')
-  int flags;
+  /**
+   * The kind of the executable (function/method, getter, setter, or
+   * constructor).
+   */
+  UnlinkedExecutableKind kind;
+
+  /**
+   * Indicates whether the executable is declared using the `abstract` keyword.
+   */
+  bool isAbstract;
+
+  /**
+   * Indicates whether the executable is declared using the `static` keyword.
+   *
+   * Note that for top level executables, 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 executable is declared using the `const` keyword.
+   */
+  bool isConst;
+
+  /**
+   * Indicates whether the executable is declared using the `factory` keyword.
+   */
+  bool isFactory;
 }
 
 /**
  * Unlinked summary information about an export declaration.
  */
 class UnlinkedExport {
   /**
    * URI used in the source code to reference the exported library.
    */
   String uri;
 
   /**
    * Combinators contained in this import declaration.
    */
   List<UnlinkedCombinator> combinators;
 }
 
 /**
  * Unlinked summary information about an import declaration.
  */
 class UnlinkedImport {
   /**
    * URI used in the source code to reference the imported library.
    */
   String uri;
 
   /**
-   * Offset of the "import" keyword.  Zero for implicit imports.
-   *
-   * Note that explicit imports may also have an offset of zero.  To
-   * distinguish explicit from implicit imports, look for the presence of the
-   * [IMPLICIT] flag.
+   * If [isImplicit] is false, offset of the "import" keyword.  If [isImplicit]
+   * is true, zero.
    */
   @informative
   int offset;
 
   /**
    * Index into [UnlinkedLibrary.prefixes] of the prefix declared by this
    * import declaration, or zero if this import declaration declares no prefix.
    *
    * Note that multiple imports can declare the same prefix.
    */
   int prefix;
 
   /**
    * Combinators contained in this import declaration.
    */
   List<UnlinkedCombinator> combinators;
 
-  @Flag('DEFERRED', 1, 'Set if this declaration uses the `deferred` keyword')
-  @Flag('IMPLICIT', 2, 'Set if this is an implicit import')
-  int flags;
+  /**
+   * Indicates whether the import declaration uses the `deferred` keyword.
+   */
+  bool isDeferred;
+
+  /**
+   * Indicates whether the import declaration is implicit.
+   */
+  bool isImplicit;
 }
 
 /**
  * Unlinked summary of an entire library.
  */
 class UnlinkedLibrary {
   /**
    * Top level and prefixed names referred to by this library.
    */
   List<UnlinkedReference> references;
@@ skipping 46 matching lines @@
   List<UnlinkedVariable> variables;
 
   /**
    * Prefixes introduced by import declarations.  The first element in this
    * array is a pseudo-prefix used by references made with no prefix.
    */
   List<UnlinkedPrefix> prefixes;
 }
 
 /**
+ * Enum used to indicate the kind of a parameter.
+ */
+enum UnlinkedParamKind {
+  /**
+   * Parameter is required.
+   */
+  required,
+
+  /**
+   * Parameter is positional optional (enclosed in `[]`)
+   */
+  positional,
+
+  /**
+   * Parameter is named optional (enclosed in `{}`)
+   */
+  named
+}
+
+/**
  * Unlinked summary information about a function parameter.
  */
 class UnlinkedParam {
   /**
    * Name of the parameter.
    */
   String name;
 
   /**
-   * If this is a function-typed parameter, the declared return type.
-   * Otherwise, the declared type.  Absent if this is a function-typed
-   * parameter and the declared return type is `void`.  Note that when strong
-   * mode is enabled, the actual type may be different due to type inference.
+   * If [isFunctionTyped] is `true`, the declared return type.  If
+   * [isFunctionTyped] is `false`, the declared type.  Absent if
+   * [isFunctionTyped] is `true` and the declared return type is `void`.  Note
+   * that when strong mode is enabled, the actual type may be different due to
+   * type inference.
    */
   UnlinkedTypeRef type;
 
   /**
-   * If this is a function-typed parameter, the parameters of the function
-   * type.
+   * If [isFunctionTyped] is `true`, the parameters of the function type.
    */
   List<UnlinkedParam> parameters;
 
-  @Flag('REQUIRED', 0, 'Indicates that this is a required parameter')
-  @Flag(
-      'POSITIONAL', 1, 'Indicates that this is a positional optional parameter')
-  @Flag('NAMED', 2, 'Indicates that this is a named optional parameter')
-  @Flag('FUNCTION_TYPED', 4, 'Set if this is a function-typed parameter')
-  @Flag('INITIALIZING_FORMAL', 8,
-      'Set if this is an initializing formal parameter')
-  int flags;
+  /**
+   * 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;
 }
 
 class UnlinkedPrefix {
   /**
    * The name of the prefix, or the empty string in the case of the
    * pseudo-prefix which represents "no prefix".
    */
   String name;
 }
 
@@ skipping 126 matching lines @@
    */
   @informative
   int unit;
 
   /**
    * 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.
    */
   UnlinkedTypeRef type;
 
-  @Flag('STATIC', 1, 'Set if the declaration includes the `static` keyword')
-  @Flag('FINAL', 2, 'Set if the declaration includes the `final` keyword')
-  @Flag('CONST', 4, 'Set if the declaration includes the `const` keyword')
-  int flags;
+  /**
+   * 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 `factory` keyword.
+   */
+  bool isFactory;

[Brian Wilkerson, 2015/10/21 20:21:08]

I think this should be "isConst".

 }