Dartdoc comments retrieved as metadata through dart2js mirrors.

tests/compiler/dart2js/mirrors_test.dart

 // Copyright (c) 2012, 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.
 
 import '../../../sdk/lib/_internal/compiler/implementation/mirrors/mirrors.dart';
 import '../../../sdk/lib/_internal/compiler/implementation/mirrors/mirrors_util.dart';
 
 import 'dart:io';
 
 int count(Iterable iterable) {
@@ skipping 20 matching lines @@
     }
   }
   return null;
 }
 
 main() {
   var scriptPath = new Path.fromNative(new Options().script);
   var dirPath = scriptPath.directoryPath;
   var libPath = dirPath.join(new Path.fromNative('../../../sdk/'));
   var inputPath = dirPath.join(new Path.fromNative('mirrors_helper.dart'));
-  var compilation = new Compilation.library([inputPath], libPath);
+  var compilation = new Compilation.library([inputPath], libPath, null,
+      <String>['--preserve-comments']);
   Expect.isNotNull(compilation, "No compilation created");
 
   var mirrors = compilation.mirrors;
   Expect.isNotNull(mirrors, "No mirror system returned from compilation");
 
   var libraries = mirrors.libraries;
   Expect.isNotNull(libraries, "No libraries map returned");
   Expect.isFalse(libraries.isEmpty, "Empty libraries map returned");
 
   var helperLibrary = libraries["mirrors_helper"];
@@ skipping 110 matching lines @@
   Expect.isNotNull(fooClass.functions);
   Expect.isNotNull(fooClass.members);
   Expect.isNotNull(fooClass.getters);
   Expect.isNotNull(fooClass.setters);
   Expect.isNotNull(fooClass.variables);
 
   //////////////////////////////////////////////////////////////////////////////
   // Metadata tests
   //////////////////////////////////////////////////////////////////////////////
 
-  var metadata = fooClass.metadata;
-  Expect.isNotNull(metadata);
-  Expect.equals(10, metadata.length);
+  var metadataList = fooClass.metadata;
+  Expect.isNotNull(metadataList);
+  Expect.equals(16, metadataList.length);
+  var metadataListIndex = 0;
+  var metadata;
 
-  // @Metadata // This is intentionally the type literal.
-  var metadata0 = metadata[0];
-  Expect.isTrue(metadata0 is InstanceMirror);
-  Expect.isFalse(metadata0.hasReflectee);
-  Expect.throws(() => metadata0.reflectee, (_) => true);
-  Expect.isTrue(metadata0 is TypeInstanceMirror);
-  var metadataType = metadata0.representedType;
+  var dartMirrorsLibrary = system.libraries['dart.mirrors'];
+  Expect.isNotNull(dartMirrorsLibrary);
+  var commentType = dartMirrorsLibrary.classes['Comment'];
+  Expect.isNotNull(commentType);
+
+  // /// Singleline doc comment.
+  metadata = metadataList[metadataListIndex++];
+  Expect.isTrue(metadata is InstanceMirror);
+  Expect.isFalse(metadata.hasReflectee);
+  Expect.throws(() => metadata.reflectee, (_) => true);
+  Expect.isTrue(metadata is CommentInstanceMirror);
+  Expect.equals(commentType.originalDeclaration, metadata.type);
+  Expect.isTrue(metadata.isDocComment);
+  Expect.stringEquals(
+      "/// Singleline doc comment.", metadata.text);
+  Expect.stringEquals(
+      "Singleline doc comment.", metadata.trimmedText);
+
+  // @Metadata
+  metadata = metadataList[metadataListIndex++];
+  Expect.isTrue(metadata is InstanceMirror);
+  Expect.isFalse(metadata.hasReflectee);
+  Expect.throws(() => metadata.reflectee, (_) => true);
+  Expect.isTrue(metadata is TypeInstanceMirror);
+  var metadataType = metadata.representedType;
   Expect.isNotNull(metadataType);
   Expect.stringEquals('Metadata', metadataType.simpleName);
 
+  // // This is intentionally the type literal.
+  metadata = metadataList[metadataListIndex++];
+  Expect.isTrue(metadata is InstanceMirror);
+  Expect.isFalse(metadata.hasReflectee);
+  Expect.throws(() => metadata.reflectee, (_) => true);
+  Expect.isTrue(metadata is CommentInstanceMirror);
+  Expect.equals(commentType.originalDeclaration, metadata.type);
+  Expect.isFalse(metadata.isDocComment);
+  Expect.stringEquals(
+      "// This is intentionally the type literal.", metadata.text);
+  Expect.stringEquals(
+      "This is intentionally the type literal.", metadata.trimmedText);
+
+  // Singleline comment 1.
+  metadata = metadataList[metadataListIndex++];
+  Expect.isTrue(metadata is InstanceMirror);
+  Expect.isFalse(metadata.hasReflectee);
+  Expect.throws(() => metadata.reflectee, (_) => true);
+  Expect.isTrue(metadata is CommentInstanceMirror);
+  Expect.equals(commentType.originalDeclaration, metadata.type);
+  Expect.isFalse(metadata.isDocComment);
+  Expect.stringEquals(
+      "// Singleline comment 1.", metadata.text);
+  Expect.stringEquals(
+      "Singleline comment 1.", metadata.trimmedText);
+
+  // Singleline comment 2.
+  metadata = metadataList[metadataListIndex++];
+  Expect.isTrue(metadata is InstanceMirror);
+  Expect.isFalse(metadata.hasReflectee);
+  Expect.throws(() => metadata.reflectee, (_) => true);
+  Expect.isTrue(metadata is CommentInstanceMirror);
+  Expect.equals(commentType.originalDeclaration, metadata.type);
+  Expect.isFalse(metadata.isDocComment);
+  Expect.stringEquals(
+      "// Singleline comment 2.", metadata.text);
+  Expect.stringEquals(
+      "Singleline comment 2.", metadata.trimmedText);
+
   // @Metadata(null)
-  var metadata1 = metadata[1];
-  Expect.isTrue(metadata1 is InstanceMirror);
-  Expect.isFalse(metadata1.hasReflectee);
-  Expect.throws(() => metadata1.reflectee, (_) => true);
-  Expect.equals(metadataType.originalDeclaration, metadata1.type);
-  metadata1.getField('data').then((InstanceMirror data) {
+  metadata = metadataList[metadataListIndex++];
+  Expect.isTrue(metadata is InstanceMirror);
+  Expect.isFalse(metadata.hasReflectee);
+  Expect.throws(() => metadata.reflectee, (_) => true);
+  Expect.equals(metadataType.originalDeclaration, metadata.type);
+  metadata.getField('data').then((InstanceMirror data) {
     Expect.isNotNull(data);
     Expect.isTrue(data.hasReflectee);
     Expect.isNull(data.reflectee);
   });
 
   // @Metadata(true)
-  var metadata2 = metadata[2];
-  Expect.isTrue(metadata2 is InstanceMirror);
-  Expect.isFalse(metadata2.hasReflectee);
-  Expect.throws(() => metadata2.reflectee, (_) => true);
-  Expect.equals(metadataType.originalDeclaration, metadata2.type);
-  metadata2.getField('data').then((InstanceMirror data) {
+  metadata = metadataList[metadataListIndex++];
+  Expect.isTrue(metadata is InstanceMirror);
+  Expect.isFalse(metadata.hasReflectee);
+  Expect.throws(() => metadata.reflectee, (_) => true);
+  Expect.equals(metadataType.originalDeclaration, metadata.type);
+  metadata.getField('data').then((InstanceMirror data) {
     Expect.isNotNull(data);
     Expect.isTrue(data.hasReflectee);
     Expect.isTrue(data.reflectee);
   });
 
   // @Metadata(false)
-  var metadata3 = metadata[3];
-  Expect.isTrue(metadata3 is InstanceMirror);
-  Expect.isFalse(metadata3.hasReflectee);
-  Expect.throws(() => metadata3.reflectee, (_) => true);
-  Expect.equals(metadataType.originalDeclaration, metadata3.type);
-  metadata3.getField('data').then((InstanceMirror data) {
+  metadata = metadataList[metadataListIndex++];
+  Expect.isTrue(metadata is InstanceMirror);
+  Expect.isFalse(metadata.hasReflectee);
+  Expect.throws(() => metadata.reflectee, (_) => true);
+  Expect.equals(metadataType.originalDeclaration, metadata.type);
+  metadata.getField('data').then((InstanceMirror data) {
     Expect.isNotNull(data);
     Expect.isTrue(data.hasReflectee);
     Expect.isFalse(data.reflectee);
   });
 
   // @Metadata(0)
-  var metadata4 = metadata[4];
-  Expect.isTrue(metadata4 is InstanceMirror);
-  Expect.isFalse(metadata4.hasReflectee);
-  Expect.throws(() => metadata4.reflectee, (_) => true);
-  Expect.equals(metadataType.originalDeclaration, metadata4.type);
-  metadata4.getField('data').then((InstanceMirror data) {
+  metadata = metadataList[metadataListIndex++];
+  Expect.isTrue(metadata is InstanceMirror);
+  Expect.isFalse(metadata.hasReflectee);
+  Expect.throws(() => metadata.reflectee, (_) => true);
+  Expect.equals(metadataType.originalDeclaration, metadata.type);
+  metadata.getField('data').then((InstanceMirror data) {
     Expect.isNotNull(data);
     Expect.isTrue(data.hasReflectee);
     Expect.equals(0, data.reflectee);
   });
 
   // @Metadata(1.5)
-  var metadata5 = metadata[5];
-  Expect.isTrue(metadata5 is InstanceMirror);
-  Expect.isFalse(metadata5.hasReflectee);
-  Expect.throws(() => metadata5.reflectee, (_) => true);
-  Expect.equals(metadataType.originalDeclaration, metadata5.type);
-  metadata5.getField('data').then((InstanceMirror data) {
+  metadata = metadataList[metadataListIndex++];
+  Expect.isTrue(metadata is InstanceMirror);
+  Expect.isFalse(metadata.hasReflectee);
+  Expect.throws(() => metadata.reflectee, (_) => true);
+  Expect.equals(metadataType.originalDeclaration, metadata.type);
+  metadata.getField('data').then((InstanceMirror data) {
     Expect.isNotNull(data);
     Expect.isTrue(data.hasReflectee);
     Expect.equals(1.5, data.reflectee);
   });
 
   // @Metadata("Foo")
-  var metadata6 = metadata[6];
-  Expect.isTrue(metadata6 is InstanceMirror);
-  Expect.isFalse(metadata6.hasReflectee);
-  Expect.throws(() => metadata6.reflectee, (_) => true);
-  Expect.equals(metadataType.originalDeclaration, metadata6.type);
-  metadata6.getField('data').then((InstanceMirror data) {
+  metadata = metadataList[metadataListIndex++];
+  Expect.isTrue(metadata is InstanceMirror);
+  Expect.isFalse(metadata.hasReflectee);
+  Expect.throws(() => metadata.reflectee, (_) => true);
+  Expect.equals(metadataType.originalDeclaration, metadata.type);
+  metadata.getField('data').then((InstanceMirror data) {
     Expect.isNotNull(data);
     Expect.isTrue(data.hasReflectee);
     Expect.stringEquals("Foo", data.reflectee);
   });
 
   // @Metadata(const ["Foo"])
-  var metadata7 = metadata[7];
-  Expect.isTrue(metadata7 is InstanceMirror);
-  Expect.isFalse(metadata7.hasReflectee);
-  Expect.throws(() => metadata7.reflectee, (_) => true);
-  Expect.equals(metadataType.originalDeclaration, metadata7.type);
-  metadata7.getField('data').then((InstanceMirror data) {
+  metadata = metadataList[metadataListIndex++];
+  Expect.isTrue(metadata is InstanceMirror);
+  Expect.isFalse(metadata.hasReflectee);
+  Expect.throws(() => metadata.reflectee, (_) => true);
+  Expect.equals(metadataType.originalDeclaration, metadata.type);
+  metadata.getField('data').then((InstanceMirror data) {
     Expect.isTrue(data is ListInstanceMirror);
     Expect.isFalse(data.hasReflectee);
     Expect.throws(() => data.reflectee, (_) => true);
     ListInstanceMirror listData = data;
     Expect.equals(1, listData.length);
     listData[0].then((InstanceMirror element) {
       Expect.isNotNull(element);
       Expect.isTrue(element.hasReflectee);
       Expect.stringEquals("Foo", element.reflectee);
     });
   });
 
-  // @Metadata(const {'foo':"Foo"})
-  var metadata8 = metadata[8];
-  Expect.isTrue(metadata8 is InstanceMirror);
-  Expect.isFalse(metadata8.hasReflectee);
-  Expect.throws(() => metadata8.reflectee, (_) => true);
-  Expect.equals(metadataType.originalDeclaration, metadata8.type);
-  metadata8.getField('data').then((InstanceMirror data) {
+  // @Metadata(/* Inline comment */ const {'foo':"Foo"})
+  metadata = metadataList[metadataListIndex++];
+  Expect.isTrue(metadata is InstanceMirror);
+  Expect.isFalse(metadata.hasReflectee);
+  Expect.throws(() => metadata.reflectee, (_) => true);
+  Expect.equals(metadataType.originalDeclaration, metadata.type);
+  metadata.getField('data').then((InstanceMirror data) {
     Expect.isTrue(data is MapInstanceMirror);
     Expect.isFalse(data.hasReflectee);
     Expect.throws(() => data.reflectee, (_) => true);
     MapInstanceMirror mapData = data;
     Expect.equals(1, mapData.length);
     var it = mapData.keys.iterator;
     Expect.isTrue(it.moveNext());
     Expect.stringEquals('foo', it.current);
     mapData['foo'].then((InstanceMirror element) {
       Expect.isNotNull(element);
       Expect.isTrue(element.hasReflectee);
       Expect.stringEquals("Foo", element.reflectee);
     });
     Expect.isNull(mapData['bar']);
   });
 
   // @metadata
-  var metadata9 = metadata[9];
-  Expect.isTrue(metadata9 is InstanceMirror);
-  Expect.isFalse(metadata9.hasReflectee);
-  Expect.throws(() => metadata9.reflectee, (_) => true);
-  Expect.equals(metadataType.originalDeclaration, metadata9.type);
-  metadata9.getField('data').then((InstanceMirror data) {
+  metadata = metadataList[metadataListIndex++];
+  Expect.isTrue(metadata is InstanceMirror);
+  Expect.isFalse(metadata.hasReflectee);
+  Expect.throws(() => metadata.reflectee, (_) => true);
+  Expect.equals(metadataType.originalDeclaration, metadata.type);
+  metadata.getField('data').then((InstanceMirror data) {
     Expect.isNotNull(data);
     Expect.isTrue(data.hasReflectee);
     Expect.isNull(data.reflectee);
   });
 
+  // /** Multiline doc comment. */
+  metadata = metadataList[metadataListIndex++];
+  Expect.isTrue(metadata is InstanceMirror);
+  Expect.isFalse(metadata.hasReflectee);
+  Expect.throws(() => metadata.reflectee, (_) => true);
+  Expect.isTrue(metadata is CommentInstanceMirror);
+  Expect.equals(commentType.originalDeclaration, metadata.type);
+  Expect.isTrue(metadata.isDocComment);
+  Expect.stringEquals(
+      "/** Multiline doc comment. */", metadata.text);
+  Expect.stringEquals(
+      "Multiline doc comment. ", metadata.trimmedText);
+
+  // /* Multiline comment. */
+  metadata = metadataList[metadataListIndex++];
+  Expect.isTrue(metadata is InstanceMirror);
+  Expect.isFalse(metadata.hasReflectee);
+  Expect.throws(() => metadata.reflectee, (_) => true);
+  Expect.isTrue(metadata is CommentInstanceMirror);
+  Expect.equals(commentType.originalDeclaration, metadata.type);
+  Expect.isFalse(metadata.isDocComment);
+  Expect.stringEquals(
+      "/* Multiline comment. */", metadata.text);
+  Expect.stringEquals(
+      "Multiline comment. ", metadata.trimmedText);
+
+  Expect.equals(metadataList.length, metadataListIndex);
+
   //////////////////////////////////////////////////////////////////////////////
   // Location test
   //////////////////////////////////////////////////////////////////////////////
 
   var fooClassLocation = fooClass.location;
   Expect.isNotNull(fooClassLocation);
-  // Expect the location to start with the first metadata.
-  Expect.equals(348, fooClassLocation.offset, "Unexpected offset");
+  // Expect the location to start with the first metadata, not including the
+  // leading comment.
+  Expect.equals(376, fooClassLocation.offset, "Unexpected offset");
   // Expect the location to end with the class body.
-  Expect.equals(227, fooClassLocation.length, "Unexpected length");
-  Expect.equals(17, fooClassLocation.line, "Unexpected line");
+  Expect.equals(332, fooClassLocation.length, "Unexpected length");
+  Expect.equals(18, fooClassLocation.line, "Unexpected line");
   Expect.equals(1, fooClassLocation.column, "Unexpected column");
 
 }
 
 // Testing abstract class Bar:
 //
 // abstract class Bar<E> {
 //
 // }
 void testBar(MirrorSystem system, LibraryMirror helperLibrary,
@@ skipping 620 matching lines @@
   Expect.isTrue(privateFactoryConstructor.isPrivate);
   Expect.isFalse(privateFactoryConstructor.isConstConstructor);
   Expect.isFalse(privateFactoryConstructor.isRedirectingConstructor);
   Expect.isFalse(privateFactoryConstructor.isGenerativeConstructor);
   Expect.isTrue(privateFactoryConstructor.isFactoryConstructor);
 
   var metadata = privateClass.metadata;
   Expect.isNotNull(metadata);
   Expect.equals(0, metadata.length);
 }