Move the wire protocol support into the public API

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 'package:html/dom.dart' as dom;
 
@@ skipping 18 matching lines @@
 const Map<String, String> specialElementFlags = const {
   'abstract': '0x01',
   'const': '0x02',
   'final': '0x04',
   'static': '0x08',
   'private': '0x10',
   'deprecated': '0x20'
 };
 
 final GeneratedFile target =
-    new GeneratedFile('../../lib/src/generated_protocol.dart', () {
+    new GeneratedFile('../../lib/plugin/protocol/generated_protocol.dart', () {
   CodegenProtocolVisitor visitor = new CodegenProtocolVisitor(readApi());
   return visitor.collectCode(visitor.visitApi);
 });
 
 /**
  * Callback type used to represent arbitrary code generation.
  */
 typedef void CodegenCallback();
 
 typedef String FromJsonSnippetCallback(String jsonPath, String json);
@@ skipping 10 matching lines @@
    * the constructor will default the member to the empty list.
    */
   static const Map<String, List<String>> _optionalConstructorArguments = const {
     'AnalysisErrorFixes': const ['fixes'],
     'SourceChange': const ['edits', 'linkedEditGroups'],
     'SourceFileEdit': const ['edits'],
     'TypeHierarchyItem': const ['interfaces', 'mixins', 'subclasses'],
   };
 
   /**
+   * The disclaimer added to the documentation comment for each of the classes
+   * that are generated.
+   */
+  static const String disclaimer =
+      'Clients are not expected to subtype this class.';
+
+  /**
    * Visitor used to produce doc comments.
    */
   final ToHtmlVisitor toHtmlVisitor;
 
   /**
    * Types implied by the API.  This includes types explicitly named in the
    * API as well as those implied by the definitions of requests, responses,
    * notifications, etc.
    */
   final Map<String, ImpliedType> impliedTypes;
@@ skipping 13 matching lines @@
     TypeDecl resolvedType = resolveTypeReferenceChain(type);
     if (resolvedType is TypeReference ||
         resolvedType is TypeEnum ||
         resolvedType is TypeObject ||
         resolvedType is TypeUnion) {
       return '$thisVar == $otherVar';
     } else if (resolvedType is TypeList) {
       String itemTypeName = dartType(resolvedType.itemType);
       String subComparison = compareEqualsCode(resolvedType.itemType, 'a', 'b');
       String closure = '($itemTypeName a, $itemTypeName b) => $subComparison';
-      return '_listEqual($thisVar, $otherVar, $closure)';
+      return 'listEqual($thisVar, $otherVar, $closure)';
     } else if (resolvedType is TypeMap) {
       String valueTypeName = dartType(resolvedType.valueType);
       String subComparison =
           compareEqualsCode(resolvedType.valueType, 'a', 'b');
       String closure = '($valueTypeName a, $valueTypeName b) => $subComparison';
-      return '_mapEqual($thisVar, $otherVar, $closure)';
+      return 'mapEqual($thisVar, $otherVar, $closure)';
     }
     throw new Exception(
         "Don't know how to compare for equality: $resolvedType");
   }
 
   /**
    * Translate each type implied by the API to a class.
    */
   void emitClasses() {
     for (ImpliedType impliedType in impliedTypes.values) {
@@ skipping 85 matching lines @@
   /**
    * Emit a class representing an data structure that doesn't exist in the
    * protocol because it is empty (e.g. the "params" object for a request that
    * doesn't have any parameters).
    */
   void emitEmptyObjectClass(String className, ImpliedType impliedType) {
     docComment(toHtmlVisitor.collectHtml(() {
       toHtmlVisitor.p(() {
         toHtmlVisitor.write(impliedType.humanReadableName);
       });
+      toHtmlVisitor.p(() {
+        toHtmlVisitor.write(disclaimer);
+      });
     }));
     writeln('class $className {');
     indent(() {
       if (emitToRequestMember(impliedType)) {
         writeln();
       }
       if (emitToResponseMember(impliedType)) {
         writeln();
       }
       if (emitToNotificationMember(impliedType)) {
@@ skipping 10 matching lines @@
    * Emit a class to encapsulate an enum.
    */
   void emitEnumClass(String className, TypeEnum type, ImpliedType impliedType) {
     docComment(toHtmlVisitor.collectHtml(() {
       toHtmlVisitor.p(() {
         toHtmlVisitor.write(impliedType.humanReadableName);
       });
       if (impliedType.type != null) {
         toHtmlVisitor.showType(null, impliedType.type);
       }
+      toHtmlVisitor.p(() {
+        toHtmlVisitor.write(disclaimer);
+      });
     }));
     writeln('class $className implements Enum {');
     indent(() {
       if (emitSpecialStaticMembers(className)) {
         writeln();
       }
       for (TypeEnumValue value in type.values) {
         docComment(toHtmlVisitor.collectHtml(() {
           toHtmlVisitor.translateHtml(value.html);
         }));
@@ skipping 104 matching lines @@
    */
   void emitObjectClass(
       String className, TypeObject type, ImpliedType impliedType) {
     docComment(toHtmlVisitor.collectHtml(() {
       toHtmlVisitor.p(() {
         toHtmlVisitor.write(impliedType.humanReadableName);
       });
       if (impliedType.type != null) {
         toHtmlVisitor.showType(null, impliedType.type);
       }
+      toHtmlVisitor.p(() {
+        toHtmlVisitor.write(disclaimer);
+      });
     }));
     write('class $className');
     if (impliedType.kind == 'refactoringFeedback') {
       write(' extends RefactoringFeedback');
     }
     if (impliedType.kind == 'refactoringOptions') {
       write(' extends RefactoringOptions');
     }
     writeln(' implements HasToJson {');
     indent(() {
@@ skipping 167 matching lines @@
    * Emit the method for decoding an object from JSON.
    */
   void emitObjectFromJsonConstructor(
       String className, TypeObject type, ImpliedType impliedType) {
     String humanReadableNameString =
         literalString(impliedType.humanReadableName);
     if (className == 'RefactoringFeedback') {
       writeln('factory RefactoringFeedback.fromJson(JsonDecoder jsonDecoder, '
           'String jsonPath, Object json, Map responseJson) {');
       indent(() {
-        writeln('return _refactoringFeedbackFromJson(jsonDecoder, jsonPath, '
+        writeln('return refactoringFeedbackFromJson(jsonDecoder, jsonPath, '
             'json, responseJson);');
       });
       writeln('}');
       return;
     }
     if (className == 'RefactoringOptions') {
       writeln('factory RefactoringOptions.fromJson(JsonDecoder jsonDecoder, '
           'String jsonPath, Object json, RefactoringKind kind) {');
       indent(() {
-        writeln('return _refactoringOptionsFromJson(jsonDecoder, jsonPath, '
+        writeln('return refactoringOptionsFromJson(jsonDecoder, jsonPath, '
             'json, kind);');
       });
       writeln('}');
       return;
     }
     writeln(
         'factory $className.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {');
     indent(() {
       writeln('if (json == null) {');
       indent(() {
@@ skipping 68 matching lines @@
         writeln('return ${className.hashCode};');
       } else {
         writeln('int hash = 0;');
         for (TypeObjectField field in type.fields) {
           String valueToCombine;
           if (field.value != null) {
             valueToCombine = field.value.hashCode.toString();
           } else {
             valueToCombine = '${field.name}.hashCode';
           }
-          writeln('hash = _JenkinsSmiHash.combine(hash, $valueToCombine);');
+          writeln('hash = JenkinsSmiHash.combine(hash, $valueToCombine);');
         }
-        writeln('return _JenkinsSmiHash.finish(hash);');
+        writeln('return JenkinsSmiHash.finish(hash);');
       }
     });
     writeln('}');
   }
 
   /**
    * If the class named [className] requires special constructors, emit them
    * and return true.
    */
   bool emitSpecialConstructors(String className) {
     switch (className) {
       case 'LinkedEditGroup':
         docComment([new dom.Text('Construct an empty LinkedEditGroup.')]);
         writeln(
             'LinkedEditGroup.empty() : this(<Position>[], 0, <LinkedEditSuggestion>[]);');
         return true;
       case 'RefactoringProblemSeverity':
         docComment([
           new dom.Text(
               'Returns the [RefactoringProblemSeverity] with the maximal severity.')
         ]);
         writeln(
             'static RefactoringProblemSeverity max(RefactoringProblemSeverity a, RefactoringProblemSeverity b) =>');
-        writeln('    _maxRefactoringProblemSeverity(a, b);');
+        writeln('    maxRefactoringProblemSeverity(a, b);');
         return true;
       default:
         return false;
     }
   }
 
   /**
    * If the class named [className] requires special getters, emit them and
    * return true.
    */
@@ skipping 35 matching lines @@
         indent(() {
           writeln('suggestions.add(suggestion);');
         });
         writeln('}');
         return true;
       case 'SourceChange':
         docComment([
           new dom.Text('Adds [edit] to the [FileEdit] for the given [file].')
         ]);
         writeln('void addEdit(String file, int fileStamp, SourceEdit edit) =>');
-        writeln('    _addEditToSourceChange(this, file, fileStamp, edit);');
+        writeln('    addEditToSourceChange(this, file, fileStamp, edit);');
         writeln();
         docComment([new dom.Text('Adds the given [FileEdit].')]);
         writeln('void addFileEdit(SourceFileEdit edit) {');
         indent(() {
           writeln('edits.add(edit);');
         });
         writeln('}');
         writeln();
         docComment([new dom.Text('Adds the given [LinkedEditGroup].')]);
         writeln('void addLinkedEditGroup(LinkedEditGroup linkedEditGroup) {');
         indent(() {
           writeln('linkedEditGroups.add(linkedEditGroup);');
         });
         writeln('}');
         writeln();
         docComment([
           new dom.Text(
               'Returns the [FileEdit] for the given [file], maybe `null`.')
         ]);
         writeln('SourceFileEdit getFileEdit(String file) =>');
-        writeln('    _getChangeFileEdit(this, file);');
+        writeln('    getChangeFileEdit(this, file);');
         return true;
       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);');
+        writeln('String apply(String code) => applyEdit(code, this);');
         return true;
       case 'SourceFileEdit':
         docComment([new dom.Text('Adds the given [Edit] to the list.')]);
-        writeln('void add(SourceEdit edit) => _addEditForSource(this, edit);');
+        writeln('void add(SourceEdit edit) => addEditForSource(this, edit);');
         writeln();
         docComment([new dom.Text('Adds the given [Edit]s.')]);
         writeln('void addAll(Iterable<SourceEdit> edits) =>');
-        writeln('    _addAllEditsForSource(this, edits);');
+        writeln('    addAllEditsForSource(this, edits);');
         return true;
       default:
         return false;
     }
   }
 
   /**
    * If the class named [className] requires special static members, emit them
    * and return true.
    */
@@ skipping 21 matching lines @@
         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);');
+        writeln('    applySequenceOfEdits(code, edits);');
         return true;
       default:
         return false;
     }
   }
 
   /**
    * Emit the toJson() code for an object class.
    */
   void emitToJsonMember(TypeObject type) {
@@ skipping 96 matching lines @@
             } else {
               return 'new $typeName.fromJson(jsonDecoder, $jsonPath, $json)';
             }
           });
         } else {
           return fromJsonCode(referencedType);
         }
       } else {
         switch (type.typeName) {
           case 'String':
-            return new FromJsonFunction('jsonDecoder._decodeString');
+            return new FromJsonFunction('jsonDecoder.decodeString');
           case 'bool':
-            return new FromJsonFunction('jsonDecoder._decodeBool');
+            return new FromJsonFunction('jsonDecoder.decodeBool');
           case 'int':
           case 'long':
-            return new FromJsonFunction('jsonDecoder._decodeInt');
+            return new FromJsonFunction('jsonDecoder.decodeInt');
           case 'object':
             return new FromJsonIdentity();
           default:
             throw new Exception('Unexpected type name ${type.typeName}');
         }
       }
     } else if (type is TypeMap) {
       FromJsonCode keyCode;
       if (dartType(type.keyType) != 'String') {
         keyCode = fromJsonCode(type.keyType);
       } else {
         keyCode = new FromJsonIdentity();
       }
       FromJsonCode valueCode = fromJsonCode(type.valueType);
       if (keyCode.isIdentity && valueCode.isIdentity) {
-        return new FromJsonFunction('jsonDecoder._decodeMap');
+        return new FromJsonFunction('jsonDecoder.decodeMap');
       } else {
         return new FromJsonSnippet((String jsonPath, String json) {
           StringBuffer result = new StringBuffer();
-          result.write('jsonDecoder._decodeMap($jsonPath, $json');
+          result.write('jsonDecoder.decodeMap($jsonPath, $json');
           if (!keyCode.isIdentity) {
             result.write(', keyDecoder: ${keyCode.asClosure}');
           }
           if (!valueCode.isIdentity) {
             result.write(', valueDecoder: ${valueCode.asClosure}');
           }
           result.write(')');
           return result.toString();
         });
       }
     } else if (type is TypeList) {
       FromJsonCode itemCode = fromJsonCode(type.itemType);
       if (itemCode.isIdentity) {
-        return new FromJsonFunction('jsonDecoder._decodeList');
+        return new FromJsonFunction('jsonDecoder.decodeList');
       } else {
         return new FromJsonSnippet((String jsonPath, String json) =>
-            'jsonDecoder._decodeList($jsonPath, $json, ${itemCode.asClosure})');
+            'jsonDecoder.decodeList($jsonPath, $json, ${itemCode.asClosure})');
       }
     } else if (type is TypeUnion) {
       List<String> decoders = <String>[];
       for (TypeDecl choice in type.choices) {
         TypeDecl resolvedChoice = resolveTypeReferenceChain(choice);
         if (resolvedChoice is TypeObject) {
           TypeObjectField field = resolvedChoice.getField(type.field);
           if (field == null) {
             throw new Exception(
                 'Each choice in the union needs a field named ${type.field}');
           }
           if (field.value == null) {
             throw new Exception(
                 'Each choice in the union needs a constant value for the field ${type.field}');
           }
           String closure = fromJsonCode(choice).asClosure;
           decoders.add('${literalString(field.value)}: $closure');
         } else {
           throw new Exception('Union types must be unions of objects.');
         }
       }
       return new FromJsonSnippet((String jsonPath, String json) =>
-          'jsonDecoder._decodeUnion($jsonPath, $json, ${literalString(type.field)}, {${decoders.join(', ')}})');
+          'jsonDecoder.decodeUnion($jsonPath, $json, ${literalString(type.field)}, {${decoders.join(', ')}})');
     } else {
       throw new Exception("Can't convert $type from JSON");
     }
   }
 
   /**
    * True if the constructor argument for the given field should be optional.
    */
   bool isOptionalConstructorArg(String className, TypeObjectField field) {
     if (field.optional) {
@@ skipping 65 matching lines @@
           dartType(type), (String value) => '$value.toJson()');
     } else {
       throw new Exception("Can't convert $resolvedType from JSON");
     }
   }
 
   @override
   visitApi() {
     outputHeader();
     writeln();
-    writeln('part of protocol;');
+    writeln('part of analysis_server.plugin.protocol.protocol;');
+    writeln();
     emitClasses();
   }
 }
 
 /**
  * Container for code that can be used to translate a data type from JSON.
  */
 abstract class FromJsonCode {
   /**
    * Get the translation code in the form of a closure.
@@ skipping 129 matching lines @@
 
   @override
   String get asClosure => '($type value) => ${callback('value')}';
 
   @override
   bool get isIdentity => false;
 
   @override
   String asSnippet(String value) => callback(value);
 }