Experimental `getDiagnostics` request (#24480).

pkg/analysis_server/tool/spec/api.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.
 
 /**
  * Data structures representing an API definition, and visitor base classes
  * for visiting those data structures.
  */
 library api;
 
 import 'dart:collection';
 
 import 'package:html/dom.dart' as dom;
 
 /**
  * Toplevel container for the API.
  */
 class Api extends ApiNode {
   final String version;
   final List<Domain> domains;
   final Types types;
   final Refactorings refactorings;
 
   Api(this.version, this.domains, this.types, this.refactorings,
-      dom.Element html)
-      : super(html);
+      dom.Element html,
+      {bool experimental})
+      : super(html, experimental);
 }
 
 /**
  * Base class for objects in the API model.
  */
 class ApiNode {
   /**
+   * A flag to indicate if this API is experimental.
+   */
+  final bool experimental;
+
+  /**
    * Html element representing this part of the API.
    */
   final dom.Element html;
 
-  ApiNode(this.html);
+  ApiNode(this.html, bool experimental)
+      : this.experimental = experimental ?? false;
 }
 
 /**
  * Base class for visiting the API definition.
  */
 abstract class ApiVisitor<T> {
   /**
    * Dispatch the given [type] to the visitor.
    */
   T visitTypeDecl(TypeDecl type) => type.accept(this);
   T visitTypeEnum(TypeEnum typeEnum);
   T visitTypeList(TypeList typeList);
   T visitTypeMap(TypeMap typeMap);
   T visitTypeObject(TypeObject typeObject);
   T visitTypeReference(TypeReference typeReference);
 
   T visitTypeUnion(TypeUnion typeUnion);
 }
 
 /**
  * Definition of a single domain.
  */
 class Domain extends ApiNode {
   final String name;
-  final bool experimental;
   final List<Request> requests;
   final List<Notification> notifications;
 
-  Domain(this.name, this.experimental, this.requests, this.notifications,
-      dom.Element html)
-      : super(html);
+  Domain(this.name, this.requests, this.notifications, dom.Element html,
+      {bool experimental})
+      : super(html, experimental);
 }
 
 /**
  * API visitor that visits the entire API hierarchically by default.
  */
 class HierarchicalApiVisitor extends ApiVisitor {
   /**
    * The API to visit.
    */
   final Api api;
@@ skipping 110 matching lines @@
    * Name of the notification, without the domain prefix.
    */
   final String event;
 
   /**
    * Type of the object associated with the "params" key in the notification
    * object, or null if the notification has no parameters.
    */
   final TypeObject params;
 
-  Notification(this.domainName, this.event, this.params, dom.Element html)
-      : super(html);
+  Notification(this.domainName, this.event, this.params, dom.Element html,
+      {bool experimental})
+      : super(html, experimental);
 
   /**
    * Get the name of the notification, including the domain prefix.
    */
   String get longEvent => '$domainName.$event';
 
   /**
    * Get the full type of the notification object, including the common "id"
    * and "error" fields.
    */
@@ skipping 23 matching lines @@
    * Type of the refactoring feedback, or null if the refactoring has no
    * feedback.
    */
   final TypeObject feedback;
 
   /**
    * Type of the refactoring options, or null if the refactoring has no options.
    */
   final TypeObject options;
 
-  Refactoring(this.kind, this.feedback, this.options, dom.Element html)
-      : super(html);
+  Refactoring(this.kind, this.feedback, this.options, dom.Element html,
+      {bool experimental})
+      : super(html, experimental);
 }
 
 /**
  * A collection of refactoring definitions.
  */
 class Refactorings extends ApiNode with IterableMixin<Refactoring> {
   final List<Refactoring> refactorings;
 
-  Refactorings(this.refactorings, dom.Element html) : super(html);
+  Refactorings(this.refactorings, dom.Element html, {bool experimental})
+      : super(html, experimental);
 
   @override
   Iterator<Refactoring> get iterator => refactorings.iterator;
 }
 
 /**
  * Description of a request method.
  */
 class Request extends ApiNode {
   /**
@@ skipping 12 matching lines @@
    */
   final TypeObject params;
 
   /**
    * Type of the object associated with the "result" key in the response object,
    * or null if the response has no results.
    */
   final TypeObject result;
 
   Request(
-      this.domainName, this.method, this.params, this.result, dom.Element html)
-      : super(html);
+      this.domainName, this.method, this.params, this.result, dom.Element html,
+      {bool experimental})
+      : super(html, experimental);
 
   /**
    * Get the name of the request, including the domain prefix.
    */
   String get longMethod => '$domainName.$method';
 
   /**
    * Get the full type of the request object, including the common "id" and
    * "method" fields.
    */
@@ skipping 24 matching lines @@
       fields.add(new TypeObjectField('result', result, null));
     }
     return new TypeObject(fields, null);
   }
 }
 
 /**
  * Base class for all possible types.
  */
 abstract class TypeDecl extends ApiNode {
-  TypeDecl(dom.Element html) : super(html);
+  TypeDecl(dom.Element html, bool experimental) : super(html, experimental);
 
   accept(ApiVisitor visitor);
 }
 
 /**
  * Description of a named type definition.
  */
 class TypeDefinition extends ApiNode {
   final String name;
   final TypeDecl type;
 
-  TypeDefinition(this.name, this.type, dom.Element html) : super(html);
+  TypeDefinition(this.name, this.type, dom.Element html, {bool experimental})
+      : super(html, experimental);
 }
 
 /**
  * Type of an enum.  We represent enums in JSON as strings, so this type
  * declaration simply lists the allowed values.
  */
 class TypeEnum extends TypeDecl {
   final List<TypeEnumValue> values;
 
-  TypeEnum(this.values, dom.Element html) : super(html);
+  TypeEnum(this.values, dom.Element html, {bool experimental})
+      : super(html, experimental);
 
   accept(ApiVisitor visitor) => visitor.visitTypeEnum(this);
 }
 
 /**
  * Description of a single allowed value for an enum.
  */
 class TypeEnumValue extends ApiNode {
   final String value;
 
-  TypeEnumValue(this.value, dom.Element html) : super(html);
+  TypeEnumValue(this.value, dom.Element html, {bool experimental})
+      : super(html, experimental);
 }
 
 /**
  * Type of a JSON list.
  */
 class TypeList extends TypeDecl {
   final TypeDecl itemType;
 
-  TypeList(this.itemType, dom.Element html) : super(html);
+  TypeList(this.itemType, dom.Element html, {bool experimental})
+      : super(html, experimental);
 
   accept(ApiVisitor visitor) => visitor.visitTypeList(this);
 }
 
 /**
  * Type of a JSON map.
  */
 class TypeMap extends TypeDecl {
   /**
    * Type of map keys.  Note that since JSON map keys must always be strings,
    * this must either be a [TypeReference] for [String], or a [TypeReference]
    * to a type which is defined in the API as an enum or a synonym for [String].
    */
   final TypeReference keyType;
 
   /**
    * Type of map values.
    */
   final TypeDecl valueType;
 
-  TypeMap(this.keyType, this.valueType, dom.Element html) : super(html);
+  TypeMap(this.keyType, this.valueType, dom.Element html, {bool experimental})
+      : super(html, experimental);
 
   accept(ApiVisitor visitor) => visitor.visitTypeMap(this);
 }
 
 /**
  * Type of a JSON object with specified fields, some of which may be optional.
  */
 class TypeObject extends TypeDecl {
   final List<TypeObjectField> fields;
 
-  TypeObject(this.fields, dom.Element html) : super(html);
+  TypeObject(this.fields, dom.Element html, {bool experimental})
+      : super(html, experimental);
 
   accept(ApiVisitor visitor) => visitor.visitTypeObject(this);
 
   /**
    * Return the field with the given [name], or null if there is no such field.
    */
   TypeObjectField getField(String name) {
     for (TypeObjectField field in fields) {
       if (field.name == name) {
         return field;
@@ skipping 10 matching lines @@
   final String name;
   final TypeDecl type;
   final bool optional;
 
   /**
    * Value that the field is required to contain, or null if it may vary.
    */
   final Object value;
 
   TypeObjectField(this.name, this.type, dom.Element html,
-      {this.optional: false, this.value})
-      : super(html);
+      {this.optional: false, this.value, bool experimental})
+      : super(html, experimental);
 }
 
 /**
  * A reference to a type which is either defined elsewhere in the API or which
  * is built-in ([String], [bool], or [int]).
  */
 class TypeReference extends TypeDecl {
   final String typeName;
 
-  TypeReference(this.typeName, dom.Element html) : super(html) {
+  TypeReference(this.typeName, dom.Element html, {bool experimental})
+      : super(html, experimental) {
     if (typeName.isEmpty) {
       throw new Exception('Empty type name');
     }
   }
 
   accept(ApiVisitor visitor) => visitor.visitTypeReference(this);
 }
 
 /**
  * A collection of type definitions.
  */
 class Types extends ApiNode with IterableMixin<TypeDefinition> {
   final Map<String, TypeDefinition> types;
 
-  Types(this.types, dom.Element html) : super(html);
+  Types(this.types, dom.Element html, {bool experimental})
+      : super(html, experimental);
 
   @override
   Iterator<TypeDefinition> get iterator => types.values.iterator;
 
   Iterable<String> get keys => types.keys;
 
   TypeDefinition operator [](String typeName) => types[typeName];
 
   bool containsKey(String typeName) => types.containsKey(typeName);
 }
 
 /**
  * Type which represents a union among multiple choices.
  */
 class TypeUnion extends TypeDecl {
   final List<TypeDecl> choices;
 
   /**
    * The field that is used to disambiguate this union
    */
   final String field;
 
-  TypeUnion(this.choices, this.field, dom.Element html) : super(html);
+  TypeUnion(this.choices, this.field, dom.Element html, {bool experimental})
+      : super(html, experimental);
 
   accept(ApiVisitor visitor) => visitor.visitTypeUnion(this);
 }