Add documentation comments for enum and enum values. Resynthesize in analyzer.

pkg/front_end/lib/src/fasta/kernel/kernel_enum_builder.dart

 // Copyright (c) 2016, 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 fasta.kernel_enum_builder;
 
 import 'package:kernel/ast.dart'
     show
         Arguments,
         Class,
@@ skipping 43 matching lines @@
         KernelNamedTypeBuilder,
         KernelProcedureBuilder,
         KernelTypeBuilder,
         LibraryBuilder,
         MemberBuilder,
         MetadataBuilder,
         Scope;
 
 class KernelEnumBuilder extends SourceClassBuilder
     implements EnumBuilder<KernelTypeBuilder, InterfaceType> {
-  final List<Object> constantNamesAndOffsets;
+  final List<Object> constantNamesAndOffsetsAndDocs;
 
   final MapLiteral toStringMap;
 
   final KernelNamedTypeBuilder intType;
 
   final KernelNamedTypeBuilder stringType;
 
   final KernelNamedTypeBuilder objectType;
 
   final KernelNamedTypeBuilder listType;
 
   KernelEnumBuilder.internal(
       String documentationComment,
       List<MetadataBuilder> metadata,
       String name,
       Scope scope,
       Scope constructors,
       Class cls,
-      this.constantNamesAndOffsets,
+      this.constantNamesAndOffsetsAndDocs,
       this.toStringMap,
       this.intType,
       this.listType,
       this.objectType,
       this.stringType,
       LibraryBuilder parent,
       int charOffset)
       : super(documentationComment, metadata, 0, name, null, null, null, scope,
             constructors, parent, null, charOffset, cls);
 
   factory KernelEnumBuilder(
+      String documentationComment,
       List<MetadataBuilder> metadata,
       String name,
-      List<Object> constantNamesAndOffsets,
+      List<Object> constantNamesAndOffsetsAndDocs,
       KernelLibraryBuilder parent,
       int charOffset,
       int charEndOffset) {
-    constantNamesAndOffsets ??= const <Object>[];
+    constantNamesAndOffsetsAndDocs ??= const <Object>[];
     // TODO(ahe): These types shouldn't be looked up in scope, they come
     // directly from dart:core.
     KernelTypeBuilder intType =
         new KernelNamedTypeBuilder("int", null, charOffset, parent.fileUri);
     KernelTypeBuilder stringType =
         new KernelNamedTypeBuilder("String", null, charOffset, parent.fileUri);
     KernelNamedTypeBuilder objectType =
         new KernelNamedTypeBuilder("Object", null, charOffset, parent.fileUri);
     Class cls = new Class(name: name);
     Map<String, MemberBuilder> members = <String, MemberBuilder>{};
@@ skipping 52 matching lines @@
         "toString",
         null,
         null,
         ProcedureKind.Method,
         parent,
         charOffset,
         charOffset,
         charEndOffset);
     members["toString"] = toStringBuilder;
     String className = name;
-    for (int i = 0; i < constantNamesAndOffsets.length; i += 2) {
-      String name = constantNamesAndOffsets[i];
-      int charOffset = constantNamesAndOffsets[i + 1];
+    for (int i = 0; i < constantNamesAndOffsetsAndDocs.length; i += 3) {
+      String name = constantNamesAndOffsetsAndDocs[i];
+      int charOffset = constantNamesAndOffsetsAndDocs[i + 1];
+      String documentationComment = constantNamesAndOffsetsAndDocs[i + 2];
       if (members.containsKey(name)) {
         parent.addCompileTimeError(templateDuplicatedName.withArguments(name),
             charOffset, parent.fileUri);
-        constantNamesAndOffsets[i] = null;
+        constantNamesAndOffsetsAndDocs[i] = null;
         continue;
       }
       if (name == className) {
         parent.addCompileTimeError(
             templateEnumConstantSameNameAsEnclosing.withArguments(name),
             charOffset,
             parent.fileUri);
-        constantNamesAndOffsets[i] = null;
+        constantNamesAndOffsetsAndDocs[i] = null;
         continue;
       }
       KernelFieldBuilder fieldBuilder = new KernelFieldBuilder(
-          null,
+          documentationComment,
           null,
           selfType,
           name,
           constMask | staticMask,
           parent,
           charOffset,
           null,
           true);
       members[name] = fieldBuilder;
       toStringEntries.add(new MapEntry(
           new IntLiteral(index), new StringLiteral("$className.$name")));
       index++;
     }
     MapLiteral toStringMap = new MapLiteral(toStringEntries, isConst: true);
     KernelEnumBuilder enumBuilder = new KernelEnumBuilder.internal(
-        null,
+        documentationComment,
         metadata,
         name,
         new Scope(members, null, parent.scope, isModifiable: false),
         new Scope(constructors, null, null, isModifiable: false),
         cls,
-        constantNamesAndOffsets,
+        constantNamesAndOffsetsAndDocs,
         toStringMap,
         intType,
         listType,
         objectType,
         stringType,
         parent,
         charOffset);
     // TODO(sigmund): dynamic should be `covariant MemberBuilder`.
     void setParent(String name, dynamic b) {
       MemberBuilder builder = b;
       builder.parent = enumBuilder;
     }
 
     members.forEach(setParent);
     constructors.forEach(setParent);
     selfType.bind(enumBuilder);
     return enumBuilder;
   }
 
   KernelTypeBuilder get mixedInType => null;
 
   InterfaceType buildType(
       LibraryBuilder library, List<KernelTypeBuilder> arguments) {
     return cls.rawType;
   }
 
   @override
   Class build(KernelLibraryBuilder libraryBuilder, LibraryBuilder coreLibrary) {
     cls.isEnum = true;
-    if (constantNamesAndOffsets.isEmpty) {
+    if (constantNamesAndOffsetsAndDocs.isEmpty) {
       libraryBuilder.addCompileTimeError(
           messageEnumDeclartionEmpty, charOffset, fileUri);
     }
     intType.resolveIn(coreLibrary.scope);
     stringType.resolveIn(coreLibrary.scope);
     objectType.resolveIn(coreLibrary.scope);
     listType.resolveIn(coreLibrary.scope);
     toStringMap.keyType = intType.build(libraryBuilder);
     toStringMap.valueType = stringType.build(libraryBuilder);
     KernelFieldBuilder indexFieldBuilder = this["index"];
     Field indexField = indexFieldBuilder.build(libraryBuilder);
     KernelProcedureBuilder toStringBuilder = this["toString"];
     toStringBuilder.body = new ReturnStatement(new MethodInvocation(
         toStringMap,
         indexGetName,
         new Arguments(<Expression>[
           new DirectPropertyGet(new ThisExpression(), indexField)
         ])));
     List<Expression> values = <Expression>[];
-    for (int i = 0; i < constantNamesAndOffsets.length; i += 2) {
-      String name = constantNamesAndOffsets[i];
+    for (int i = 0; i < constantNamesAndOffsetsAndDocs.length; i += 3) {
+      String name = constantNamesAndOffsetsAndDocs[i];
       if (name != null) {
         KernelFieldBuilder builder = this[name];
         values.add(new StaticGet(builder.build(libraryBuilder)));
       }
     }
     KernelFieldBuilder valuesBuilder = this["values"];
     valuesBuilder.build(libraryBuilder);
     valuesBuilder.initializer =
         new ListLiteral(values, typeArgument: cls.rawType, isConst: true);
     KernelConstructorBuilder constructorBuilder = constructorScopeBuilder[""];
@@ skipping 11 matching lines @@
       // unnamed constructor requires no arguments. But that information isn't
       // always available at this point, and it's not really a situation that
       // can happen unless you start modifying the SDK sources.
       addCompileTimeError(messageNoUnnamedConstructorInObject, -1);
     } else {
       constructor.initializers.add(
           new SuperInitializer(superConstructor.target, new Arguments.empty())
             ..parent = constructor);
     }
     int index = 0;
-    for (int i = 0; i < constantNamesAndOffsets.length; i += 2) {
-      String constant = constantNamesAndOffsets[i];
+    for (int i = 0; i < constantNamesAndOffsetsAndDocs.length; i += 3) {
+      String constant = constantNamesAndOffsetsAndDocs[i];
       if (constant != null) {
         KernelFieldBuilder field = this[constant];
         field.build(libraryBuilder);
         Arguments arguments =
             new Arguments(<Expression>[new IntLiteral(index++)]);
         field.initializer =
             new ConstructorInvocation(constructor, arguments, isConst: true);
       }
     }
     return super.build(libraryBuilder, coreLibrary);
   }
 
   @override
   Builder findConstructorOrFactory(
       String name, int charOffset, Uri uri, LibraryBuilder library) {
     return null;
   }
 }