Introduce convenience methods into generated analysis server classes.

pkg/analysis_server/tool/spec/codegen_dart_protocol.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.
 
 library codegen.protocol;
 
 import 'dart:convert';
 
 import 'api.dart';
 import 'codegen_tools.dart';
 import 'from_html.dart';
 import 'implied_types.dart';
 import 'to_html.dart';
 
+import 'package:html5lib/dom.dart' as dom;
+
 /**
  * Container for code that can be used to translate a data type from JSON.
  */
 abstract class FromJsonCode {
   /**
    * True if the data type is already in JSON form, so the translation is the
    * identity function.
    */
   bool get isIdentity;
 
@@ skipping 131 matching lines @@
  * Representation of FromJsonCode for the identity transformation.
  */
 class ToJsonIdentity extends ToJsonSnippet {
   ToJsonIdentity(String type) : super(type, (String value) => value);
 
   @override
   bool get isIdentity => true;
 }
 
 /**
+ * Special flags that need to be inserted into the declaration of the Element
+ * class.
+ */
+const Map<String, String> specialElementFlags = const {
+  'abstract': '0x01',
+  'const': '0x02',
+  'final': '0x04',
+  'static': '0x08',
+  'private': '0x10',
+  'deprecated': '0x20'
+};
+
+/**
  * Visitor which produces Dart code representing the API.
  */
 class CodegenProtocolVisitor extends HierarchicalApiVisitor with CodeGenerator {
   /**
    * Type references in the spec that are named something else in Dart.
    */
   static const Map<String, String> _typeRenames = const {
     'object': 'Object',
   };
 
@@ skipping 49 matching lines @@
     docComment(toHtmlVisitor.collectHtml(() {
       toHtmlVisitor.p(() {
         toHtmlVisitor.write(impliedType.humanReadableName);
       });
       if (impliedType.type != null) {
         toHtmlVisitor.showType(null, impliedType.type);
       }
     }));
     writeln('class $className implements HasToJson {');
     indent(() {
+      if (emitSpecialStaticMembers(className)) {
+        writeln();
+      }
       for (TypeObjectField field in type.fields) {
         if (field.value != null) {
           continue;
         }
         docComment(toHtmlVisitor.collectHtml(() {
           toHtmlVisitor.translateHtml(field.html);
         }));
         writeln('${dartType(field.type)} ${field.name};');
         writeln();
       }
       emitObjectConstructor(type, className);
       writeln();
       emitObjectFromJsonConstructor(className, type, impliedType);
       writeln();
       if (emitConvenienceConstructor(className, impliedType)) {
         writeln();
       }
+      if (emitSpecialConstructors(className)) {
+        writeln();
+      }
+      if (emitSpecialGetters(className)) {
+        writeln();
+      }
       emitToJsonMember(type);
       writeln();
       if (emitToRequestMember(impliedType)) {
         writeln();
       }
+      if (emitSpecialMembers(className)) {
+        writeln();
+      }
       writeln('@override');
       writeln('String toString() => JSON.encode(toJson());');
       writeln();
       emitObjectEqualsMember(type, className);
       writeln();
       emitObjectHashCode(type);
     });
     writeln('}');
   }
 
   /**
+   * If the class named [className] requires special static members, emit them
+   * and return true.
+   */
+  bool emitSpecialStaticMembers(String className) {
+    switch (className) {
+      case 'Element':
+        List<String> makeFlagsArgs = <String>[];
+        List<String> makeFlagsStatements = <String>[];
+        specialElementFlags.forEach((String name, String value) {
+          String flag = 'FLAG_${name.toUpperCase()}';
+          String camelName = camelJoin(['is', name]);
+          writeln('static const int $flag = $value;');
+          makeFlagsArgs.add('$camelName: false');
+          makeFlagsStatements.add('if ($camelName) flags |= $flag;');
+        });
+        writeln();
+        writeln('static int makeFlags({${makeFlagsArgs.join(', ')}}) {');
+        indent(() {
+          writeln('int flags = 0;');
+          for (String statement in makeFlagsStatements) {
+            writeln(statement);
+          }
+          writeln('return flags;');
+        });
+        writeln('}');
+        return true;
+      case 'SourceEdit':
+        docComment([new dom.Text('Get the result of applying a set of ' +
+            '[edits] to the given [code].  Edits are applied in the order ' +
+            'they appear in [edits].')]);
+        writeln(
+            'static String applySequence(String code, Iterable<SourceEdit> edits) =>');
+        writeln('    _applySequence(code, edits);');
+        return true;
+      default:
+        return false;
+    }
+  }
+
+  /**
+   * If the class named [className] requires special constructors, emit them
+   * and return true.
+   */
+  bool emitSpecialConstructors(String className) {
+    switch (className) {
+      case 'AnalysisError':
+        docComment([new dom.Text(
+            'Construct based on error information from the analyzer engine.')]);
+        writeln(
+            'factory AnalysisError.fromEngine(engine.LineInfo lineInfo, engine.AnalysisError error) =>'
+            );
+        writeln('    _analysisErrorFromEngine(lineInfo, error);');
+        return true;
+      case 'ElementKind':
+        docComment([new dom.Text(
+            'Construct based on a value from the analyzer engine.')]);
+        writeln('factory ElementKind.fromEngine(engine.ElementKind kind) =>');
+        writeln('    _elementKindFromEngine(kind);');
+        return true;
+      case 'SourceEdit':
+        docComment([new dom.Text('Construct based on a SourceRange.')]);
+        writeln(
+            'SourceEdit.range(engine.SourceRange range, String replacement, {String id})');
+        writeln('    : this(range.offset, range.length, replacement, id: id);');
+        return true;
+      default:
+        return false;
+    }
+  }
+
+  /**
+   * If  the class named [className] requires special getters, emit them and
+   * return true.
+   */
+  bool emitSpecialGetters(String className) {
+    switch (className) {
+      case 'Element':
+        for (String name in specialElementFlags.keys) {
+          String flag = 'FLAG_${name.toUpperCase()}';
+          writeln('bool get ${camelJoin(['is', name])} => (flags & $flag) != 0;'
+              );
+        }
+        return true;
+      case 'SourceEdit':
+        docComment([new dom.Text('The end of the region to be modified.')]);
+        writeln('int get end => offset + length;');
+        return true;
+      default:
+        return false;
+    }
+  }
+
+  /**
+   * If the class named [className] requires special members, emit them and
+   * return true.
+   */
+  bool emitSpecialMembers(String className) {
+    switch (className) {
+      case 'SourceEdit':
+        docComment([new dom.Text(
+            'Get the result of applying the edit to the given [code].')]);
+        writeln('String apply(String code) => _applyEdit(code, this);');
+        return true;
+      default:
+        return false;
+    }
+  }
+
+  /**
    * Emit the constructor for an object class.
    */
   void emitObjectConstructor(TypeObject type, String className) {
     List<String> args = <String>[];
     List<String> optionalArgs = <String>[];
     for (TypeObjectField field in type.fields) {
       if (field.value != null) {
         continue;
       }
       String arg = 'this.${field.name}';
@@ skipping 116 matching lines @@
     docComment(toHtmlVisitor.collectHtml(() {
       toHtmlVisitor.p(() {
         toHtmlVisitor.write(impliedType.humanReadableName);
       });
       if (impliedType.type != null) {
         toHtmlVisitor.showType(null, impliedType.type);
       }
     }));
     writeln('class $className {');
     indent(() {
+      if (emitSpecialStaticMembers(className)) {
+        writeln();
+      }
       for (TypeEnumValue value in type.values) {
         docComment(toHtmlVisitor.collectHtml(() {
           toHtmlVisitor.translateHtml(value.html);
         }));
         String valueString = literalString(value.value);
         writeln(
             'static const ${value.value} = const $className._($valueString);');
         writeln();
       }
       writeln('final String name;');
       writeln();
       writeln('const $className._(this.name);');
       writeln();
       emitEnumClassConstructor(className, type);
       writeln();
       emitEnumFromJsonConstructor(className, type, impliedType);
       writeln();
+      if (emitSpecialConstructors(className)) {
+        writeln();
+      }
+      if (emitSpecialGetters(className)) {
+        writeln();
+      }
+      if (emitSpecialMembers(className)) {
+        writeln();
+      }
       writeln('@override');
       writeln('String toString() => "$className.\$name";');
       writeln();
       writeln('String toJson() => name;');
     });
     writeln('}');
   }
 
   /**
    * Emit the constructor for an enum class.
@@ skipping 397 matching lines @@
   CodegenProtocolVisitor visitor = new CodegenProtocolVisitor(readApi());
   return visitor.collectCode(visitor.visitApi);
 });
 
 /**
  * Translate spec_input.html into protocol_matchers.dart.
  */
 main() {
   target.generate();
 }