Report HintCode.UNDEFINED_IDENTIFIER and HintCode.UNDEFINED_MEMBER for unresolved names in comments.

pkg/analyzer/test/generated/resolver_test.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 analyzer.test.generated.resolver_test;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
@@ skipping 179 matching lines @@
     futureElement.constructors = <ConstructorElement>[futureConstructor];
     //   Future then(onValue(T value), { Function onError });
     TypeDefiningElement futureThenR = DynamicElementImpl.instance;
     if (context.analysisOptions.strongMode) {
       futureThenR = ElementFactory.typeParameterWithType('R');
     }
     FunctionElementImpl thenOnValue = ElementFactory.functionElement3(
         'onValue', futureThenR, [futureElement.typeParameters[0]], null);
 
     DartType futureRType = futureElement.type.substitute4([futureThenR.type]);
-    MethodElementImpl thenMethod = ElementFactory.methodElementWithParameters(
-        futureElement, "then", futureRType, [
+    MethodElementImpl thenMethod = ElementFactory
+        .methodElementWithParameters(futureElement, "then", futureRType, [
       ElementFactory.requiredParameter2("onValue", thenOnValue.type),
       ElementFactory.namedParameter2("onError", provider.functionType)
     ]);
     if (!futureThenR.type.isDynamic) {
       thenMethod.typeParameters = [futureThenR];
     }
     thenOnValue.enclosingElement = thenMethod;
     thenOnValue.type = new FunctionTypeImpl(thenOnValue);
     (thenMethod.parameters[0] as ParameterElementImpl).type = thenOnValue.type;
     thenMethod.type = new FunctionTypeImpl(thenMethod);
@@ skipping 68 matching lines @@
       ElementFactory.getterElement("context2D", false, context2dElement.type)
     ];
     canvasElement.fields = canvasElement.accessors
         .map((PropertyAccessorElement accessor) => accessor.variable)
         .toList();
     ClassElementImpl documentElement =
         ElementFactory.classElement("Document", elementType);
     ClassElementImpl htmlDocumentElement =
         ElementFactory.classElement("HtmlDocument", documentElement.type);
     htmlDocumentElement.methods = <MethodElement>[
-      ElementFactory.methodElement(
-          "query", elementType, <DartType>[provider.stringType])
+      ElementFactory
+          .methodElement("query", elementType, <DartType>[provider.stringType])
     ];
     htmlUnit.types = <ClassElement>[
       ElementFactory.classElement("AnchorElement", elementType),
       ElementFactory.classElement("BodyElement", elementType),
       ElementFactory.classElement("ButtonElement", elementType),
       canvasElement,
       contextElement,
       context2dElement,
       ElementFactory.classElement("DivElement", elementType),
       documentElement,
       elementElement,
       htmlDocumentElement,
       ElementFactory.classElement("InputElement", elementType),
       ElementFactory.classElement("SelectElement", elementType)
     ];
     htmlUnit.functions = <FunctionElement>[
       ElementFactory.functionElement3("query", elementElement,
           <ClassElement>[provider.stringType.element], ClassElement.EMPTY_LIST)
     ];
-    TopLevelVariableElementImpl document = ElementFactory
-        .topLevelVariableElement3(
+    TopLevelVariableElementImpl document =
+        ElementFactory.topLevelVariableElement3(
             "document", false, true, htmlDocumentElement.type);
     htmlUnit.topLevelVariables = <TopLevelVariableElement>[document];
     htmlUnit.accessors = <PropertyAccessorElement>[document.getter];
     LibraryElementImpl htmlLibrary = new LibraryElementImpl.forNode(
         coreContext, AstFactory.libraryIdentifier2(["dart", "dom", "html"]));
     htmlLibrary.definingCompilationUnit = htmlUnit;
     //
     // dart:math
     //
     CompilationUnitElementImpl mathUnit =
@@ skipping 3128 matching lines @@
   }
 
   void test_undefinedGetter_message() {
     // The implementation of HintCode.UNDEFINED_SETTER assumes that
     // UNDEFINED_SETTER in StaticTypeWarningCode and StaticWarningCode are the
     // same, this verifies that assumption.
     expect(StaticWarningCode.UNDEFINED_GETTER.message,
         StaticTypeWarningCode.UNDEFINED_GETTER.message);
   }
 
+  void test_undefinedIdentifier_inComment_prefixed_prefix() {
+    Source source = addSource(r'''
+/// [Foo.bar]
+main() {}
+''');
+    computeLibrarySourceErrors(source);
+    assertErrors(source, [HintCode.UNDEFINED_IDENTIFIER]);
+    verify([source]);
+  }
+
+  void test_undefinedIdentifier_inComment_simple() {
+    Source source = addSource(r'''
+/// [Foo]
+main() {}
+''');
+    computeLibrarySourceErrors(source);
+    assertErrors(source, [HintCode.UNDEFINED_IDENTIFIER]);
+    verify([source]);
+  }
+
+  void test_undefinedMember_inComment_prefixed_name() {
+    Source source = addSource(r'''
+class Foo {}
+/// [Foo.bar]
+main() {}
+''');
+    computeLibrarySourceErrors(source);
+    assertErrors(source, [HintCode.UNDEFINED_MEMBER]);
+    verify([source]);
+  }
+
   void test_undefinedMethod() {
     Source source = addSource(r'''
 f() {
   var a = 'str';
   a.notAMethodOnString();
 }''');
     computeLibrarySourceErrors(source);
     assertErrors(source, [HintCode.UNDEFINED_METHOD]);
   }
 
@@ skipping 1671 matching lines @@
 
   void test_getMapOfMembersInheritedFromInterfaces_implicitExtends() {
     // class A {}
     ClassElementImpl classA = ElementFactory.classElement2("A");
     MemberMap mapA =
         _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classA);
     expect(mapA.size, _numOfMembersInObject);
     _assertNoErrors(classA);
   }
 
-  void test_getMapOfMembersInheritedFromInterfaces_inconsistentMethodInheritance_getter_method() {
+  void
+      test_getMapOfMembersInheritedFromInterfaces_inconsistentMethodInheritance_getter_method() {
     // class I1 { int m(); }
     // class I2 { int get m; }
     // class A implements I2, I1 {}
     ClassElementImpl classI1 = ElementFactory.classElement2("I1");
     String methodName = "m";
     MethodElement methodM =
         ElementFactory.methodElement(methodName, _typeProvider.intType);
     classI1.methods = <MethodElement>[methodM];
     ClassElementImpl classI2 = ElementFactory.classElement2("I2");
     PropertyAccessorElement getter =
         ElementFactory.getterElement(methodName, false, _typeProvider.intType);
     classI2.accessors = <PropertyAccessorElement>[getter];
     ClassElementImpl classA = ElementFactory.classElement2("A");
     classA.interfaces = <InterfaceType>[classI2.type, classI1.type];
     MemberMap mapA =
         _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classA);
     expect(mapA.size, _numOfMembersInObject);
     expect(mapA.get(methodName), isNull);
     _assertErrors(classA,
         [StaticWarningCode.INCONSISTENT_METHOD_INHERITANCE_GETTER_AND_METHOD]);
   }
 
-  void test_getMapOfMembersInheritedFromInterfaces_inconsistentMethodInheritance_int_str() {
+  void
+      test_getMapOfMembersInheritedFromInterfaces_inconsistentMethodInheritance_int_str() {
     // class I1 { int m(); }
     // class I2 { String m(); }
     // class A implements I1, I2 {}
     ClassElementImpl classI1 = ElementFactory.classElement2("I1");
     String methodName = "m";
     MethodElement methodM1 =
         ElementFactory.methodElement(methodName, null, [_typeProvider.intType]);
     classI1.methods = <MethodElement>[methodM1];
     ClassElementImpl classI2 = ElementFactory.classElement2("I2");
-    MethodElement methodM2 = ElementFactory.methodElement(
-        methodName, null, [_typeProvider.stringType]);
+    MethodElement methodM2 = ElementFactory
+        .methodElement(methodName, null, [_typeProvider.stringType]);
     classI2.methods = <MethodElement>[methodM2];
     ClassElementImpl classA = ElementFactory.classElement2("A");
     classA.interfaces = <InterfaceType>[classI1.type, classI2.type];
     MemberMap mapA =
         _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classA);
     expect(mapA.size, _numOfMembersInObject);
     expect(mapA.get(methodName), isNull);
     _assertErrors(
         classA, [StaticTypeWarningCode.INCONSISTENT_METHOD_INHERITANCE]);
   }
 
-  void test_getMapOfMembersInheritedFromInterfaces_inconsistentMethodInheritance_method_getter() {
+  void
+      test_getMapOfMembersInheritedFromInterfaces_inconsistentMethodInheritance_method_getter() {
     // class I1 { int m(); }
     // class I2 { int get m; }
     // class A implements I1, I2 {}
     ClassElementImpl classI1 = ElementFactory.classElement2("I1");
     String methodName = "m";
     MethodElement methodM =
         ElementFactory.methodElement(methodName, _typeProvider.intType);
     classI1.methods = <MethodElement>[methodM];
     ClassElementImpl classI2 = ElementFactory.classElement2("I2");
     PropertyAccessorElement getter =
         ElementFactory.getterElement(methodName, false, _typeProvider.intType);
     classI2.accessors = <PropertyAccessorElement>[getter];
     ClassElementImpl classA = ElementFactory.classElement2("A");
     classA.interfaces = <InterfaceType>[classI1.type, classI2.type];
     MemberMap mapA =
         _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classA);
     expect(mapA.size, _numOfMembersInObject);
     expect(mapA.get(methodName), isNull);
     _assertErrors(classA,
         [StaticWarningCode.INCONSISTENT_METHOD_INHERITANCE_GETTER_AND_METHOD]);
   }
 
-  void test_getMapOfMembersInheritedFromInterfaces_inconsistentMethodInheritance_numOfRequiredParams() {
+  void
+      test_getMapOfMembersInheritedFromInterfaces_inconsistentMethodInheritance_numOfRequiredParams() {
     // class I1 { dynamic m(int, [int]); }
     // class I2 { dynamic m(int, int, int); }
     // class A implements I1, I2 {}
     ClassElementImpl classI1 = ElementFactory.classElement2("I1");
     String methodName = "m";
     MethodElementImpl methodM1 =
         ElementFactory.methodElement(methodName, _typeProvider.dynamicType);
     ParameterElementImpl parameter1 =
         new ParameterElementImpl.forNode(AstFactory.identifier3("a1"));
     parameter1.type = _typeProvider.intType;
@@ skipping 28 matching lines @@
     ClassElementImpl classA = ElementFactory.classElement2("A");
     classA.interfaces = <InterfaceType>[classI1.type, classI2.type];
     MemberMap mapA =
         _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classA);
     expect(mapA.size, _numOfMembersInObject);
     expect(mapA.get(methodName), isNull);
     _assertErrors(
         classA, [StaticTypeWarningCode.INCONSISTENT_METHOD_INHERITANCE]);
   }
 
-  void test_getMapOfMembersInheritedFromInterfaces_inconsistentMethodInheritance_str_int() {
+  void
+      test_getMapOfMembersInheritedFromInterfaces_inconsistentMethodInheritance_str_int() {
     // class I1 { int m(); }
     // class I2 { String m(); }
     // class A implements I2, I1 {}
     ClassElementImpl classI1 = ElementFactory.classElement2("I1");
     String methodName = "m";
-    MethodElement methodM1 = ElementFactory.methodElement(
-        methodName, null, [_typeProvider.stringType]);
+    MethodElement methodM1 = ElementFactory
+        .methodElement(methodName, null, [_typeProvider.stringType]);
     classI1.methods = <MethodElement>[methodM1];
     ClassElementImpl classI2 = ElementFactory.classElement2("I2");
     MethodElement methodM2 =
         ElementFactory.methodElement(methodName, null, [_typeProvider.intType]);
     classI2.methods = <MethodElement>[methodM2];
     ClassElementImpl classA = ElementFactory.classElement2("A");
     classA.interfaces = <InterfaceType>[classI2.type, classI1.type];
     MemberMap mapA =
         _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classA);
     expect(mapA.size, _numOfMembersInObject);
@@ skipping 81 matching lines @@
     ClassElementImpl classA = ElementFactory.classElement2("A");
     classA.interfaces = <InterfaceType>[classI1.type, classI2.type];
     MemberMap mapA =
         _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classA);
     expect(mapA.size, _numOfMembersInObject + 2);
     expect(mapA.get(methodName1), same(methodM1));
     expect(mapA.get(methodName2), same(methodM2));
     _assertNoErrors(classA);
   }
 
-  void test_getMapOfMembersInheritedFromInterfaces_union_multipleSubtypes_2_getters() {
+  void
+      test_getMapOfMembersInheritedFromInterfaces_union_multipleSubtypes_2_getters() {
     // class I1 { int get g; }
     // class I2 { num get g; }
     // class A implements I1, I2 {}
     ClassElementImpl classI1 = ElementFactory.classElement2("I1");
     String accessorName = "g";
     PropertyAccessorElement getter1 = ElementFactory.getterElement(
         accessorName, false, _typeProvider.intType);
     classI1.accessors = <PropertyAccessorElement>[getter1];
     ClassElementImpl classI2 = ElementFactory.classElement2("I2");
     PropertyAccessorElement getter2 = ElementFactory.getterElement(
         accessorName, false, _typeProvider.numType);
     classI2.accessors = <PropertyAccessorElement>[getter2];
     ClassElementImpl classA = ElementFactory.classElement2("A");
     classA.interfaces = <InterfaceType>[classI1.type, classI2.type];
     MemberMap mapA =
         _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classA);
     expect(mapA.size, _numOfMembersInObject + 1);
     PropertyAccessorElement syntheticAccessor = ElementFactory.getterElement(
         accessorName, false, _typeProvider.dynamicType);
     expect(mapA.get(accessorName).type, syntheticAccessor.type);
     _assertNoErrors(classA);
   }
 
-  void test_getMapOfMembersInheritedFromInterfaces_union_multipleSubtypes_2_methods() {
+  void
+      test_getMapOfMembersInheritedFromInterfaces_union_multipleSubtypes_2_methods() {
     // class I1 { dynamic m(int); }
     // class I2 { dynamic m(num); }
     // class A implements I1, I2 {}
     ClassElementImpl classI1 = ElementFactory.classElement2("I1");
     String methodName = "m";
     MethodElementImpl methodM1 =
         ElementFactory.methodElement(methodName, _typeProvider.dynamicType);
     ParameterElementImpl parameter1 =
         new ParameterElementImpl.forNode(AstFactory.identifier3("a0"));
     parameter1.type = _typeProvider.intType;
@@ skipping 13 matching lines @@
     classA.interfaces = <InterfaceType>[classI1.type, classI2.type];
     MemberMap mapA =
         _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classA);
     expect(mapA.size, _numOfMembersInObject + 1);
     MethodElement syntheticMethod = ElementFactory.methodElement(
         methodName, _typeProvider.dynamicType, [_typeProvider.dynamicType]);
     expect(mapA.get(methodName).type, syntheticMethod.type);
     _assertNoErrors(classA);
   }
 
-  void test_getMapOfMembersInheritedFromInterfaces_union_multipleSubtypes_2_setters() {
+  void
+      test_getMapOfMembersInheritedFromInterfaces_union_multipleSubtypes_2_setters() {
     // class I1 { set s(int); }
     // class I2 { set s(num); }
     // class A implements I1, I2 {}
     ClassElementImpl classI1 = ElementFactory.classElement2("I1");
     String accessorName = "s";
     PropertyAccessorElement setter1 = ElementFactory.setterElement(
         accessorName, false, _typeProvider.intType);
     classI1.accessors = <PropertyAccessorElement>[setter1];
     ClassElementImpl classI2 = ElementFactory.classElement2("I2");
     PropertyAccessorElement setter2 = ElementFactory.setterElement(
         accessorName, false, _typeProvider.numType);
     classI2.accessors = <PropertyAccessorElement>[setter2];
     ClassElementImpl classA = ElementFactory.classElement2("A");
     classA.interfaces = <InterfaceType>[classI1.type, classI2.type];
     MemberMap mapA =
         _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classA);
     expect(mapA.size, _numOfMembersInObject + 1);
     PropertyAccessorElementImpl syntheticAccessor = ElementFactory
         .setterElement(accessorName, false, _typeProvider.dynamicType);
     syntheticAccessor.returnType = _typeProvider.dynamicType;
     expect(mapA.get("$accessorName=").type, syntheticAccessor.type);
     _assertNoErrors(classA);
   }
 
-  void test_getMapOfMembersInheritedFromInterfaces_union_multipleSubtypes_3_getters() {
+  void
+      test_getMapOfMembersInheritedFromInterfaces_union_multipleSubtypes_3_getters() {
     // class A {}
     // class B extends A {}
     // class C extends B {}
     // class I1 { A get g; }
     // class I2 { B get g; }
     // class I3 { C get g; }
     // class D implements I1, I2, I3 {}
     ClassElementImpl classA = ElementFactory.classElement2("A");
     ClassElementImpl classB = ElementFactory.classElement("B", classA.type);
     ClassElementImpl classC = ElementFactory.classElement("C", classB.type);
@@ skipping 18 matching lines @@
     ];
     MemberMap mapD =
         _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classD);
     expect(mapD.size, _numOfMembersInObject + 1);
     PropertyAccessorElement syntheticAccessor = ElementFactory.getterElement(
         accessorName, false, _typeProvider.dynamicType);
     expect(mapD.get(accessorName).type, syntheticAccessor.type);
     _assertNoErrors(classD);
   }
 
-  void test_getMapOfMembersInheritedFromInterfaces_union_multipleSubtypes_3_methods() {
+  void
+      test_getMapOfMembersInheritedFromInterfaces_union_multipleSubtypes_3_methods() {
     // class A {}
     // class B extends A {}
     // class C extends B {}
     // class I1 { dynamic m(A a); }
     // class I2 { dynamic m(B b); }
     // class I3 { dynamic m(C c); }
     // class D implements I1, I2, I3 {}
     ClassElementImpl classA = ElementFactory.classElement2("A");
     ClassElementImpl classB = ElementFactory.classElement("B", classA.type);
     ClassElementImpl classC = ElementFactory.classElement("C", classB.type);
@@ skipping 33 matching lines @@
     ];
     MemberMap mapD =
         _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classD);
     expect(mapD.size, _numOfMembersInObject + 1);
     MethodElement syntheticMethod = ElementFactory.methodElement(
         methodName, _typeProvider.dynamicType, [_typeProvider.dynamicType]);
     expect(mapD.get(methodName).type, syntheticMethod.type);
     _assertNoErrors(classD);
   }
 
-  void test_getMapOfMembersInheritedFromInterfaces_union_multipleSubtypes_3_setters() {
+  void
+      test_getMapOfMembersInheritedFromInterfaces_union_multipleSubtypes_3_setters() {
     // class A {}
     // class B extends A {}
     // class C extends B {}
     // class I1 { set s(A); }
     // class I2 { set s(B); }
     // class I3 { set s(C); }
     // class D implements I1, I2, I3 {}
     ClassElementImpl classA = ElementFactory.classElement2("A");
     ClassElementImpl classB = ElementFactory.classElement("B", classA.type);
     ClassElementImpl classC = ElementFactory.classElement("C", classB.type);
@@ skipping 19 matching lines @@
     MemberMap mapD =
         _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classD);
     expect(mapD.size, _numOfMembersInObject + 1);
     PropertyAccessorElementImpl syntheticAccessor = ElementFactory
         .setterElement(accessorName, false, _typeProvider.dynamicType);
     syntheticAccessor.returnType = _typeProvider.dynamicType;
     expect(mapD.get("$accessorName=").type, syntheticAccessor.type);
     _assertNoErrors(classD);
   }
 
-  void test_getMapOfMembersInheritedFromInterfaces_union_oneSubtype_2_methods() {
+  void
+      test_getMapOfMembersInheritedFromInterfaces_union_oneSubtype_2_methods() {
     // class I1 { int m(); }
     // class I2 { int m([int]); }
     // class A implements I1, I2 {}
     ClassElementImpl classI1 = ElementFactory.classElement2("I1");
     String methodName = "m";
     MethodElement methodM1 =
         ElementFactory.methodElement(methodName, _typeProvider.intType);
     classI1.methods = <MethodElement>[methodM1];
     ClassElementImpl classI2 = ElementFactory.classElement2("I2");
     MethodElementImpl methodM2 =
         ElementFactory.methodElement(methodName, _typeProvider.intType);
     ParameterElementImpl parameter1 =
         new ParameterElementImpl.forNode(AstFactory.identifier3("a1"));
     parameter1.type = _typeProvider.intType;
     parameter1.parameterKind = ParameterKind.POSITIONAL;
     methodM2.parameters = <ParameterElement>[parameter1];
     classI2.methods = <MethodElement>[methodM2];
     ClassElementImpl classA = ElementFactory.classElement2("A");
     classA.interfaces = <InterfaceType>[classI1.type, classI2.type];
     MemberMap mapA =
         _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classA);
     expect(mapA.size, _numOfMembersInObject + 1);
     expect(mapA.get(methodName), same(methodM2));
     _assertNoErrors(classA);
   }
 
-  void test_getMapOfMembersInheritedFromInterfaces_union_oneSubtype_3_methods() {
+  void
+      test_getMapOfMembersInheritedFromInterfaces_union_oneSubtype_3_methods() {
     // class I1 { int m(); }
     // class I2 { int m([int]); }
     // class I3 { int m([int, int]); }
     // class A implements I1, I2, I3 {}
     ClassElementImpl classI1 = ElementFactory.classElement2("I1");
     String methodName = "m";
     MethodElementImpl methodM1 =
         ElementFactory.methodElement(methodName, _typeProvider.intType);
     classI1.methods = <MethodElement>[methodM1];
     ClassElementImpl classI2 = ElementFactory.classElement2("I2");
@@ skipping 24 matching lines @@
       classI2.type,
       classI3.type
     ];
     MemberMap mapA =
         _inheritanceManager.getMapOfMembersInheritedFromInterfaces(classA);
     expect(mapA.size, _numOfMembersInObject + 1);
     expect(mapA.get(methodName), same(methodM3));
     _assertNoErrors(classA);
   }
 
-  void test_getMapOfMembersInheritedFromInterfaces_union_oneSubtype_4_methods() {
+  void
+      test_getMapOfMembersInheritedFromInterfaces_union_oneSubtype_4_methods() {
     // class I1 { int m(); }
     // class I2 { int m(); }
     // class I3 { int m([int]); }
     // class I4 { int m([int, int]); }
     // class A implements I1, I2, I3, I4 {}
     ClassElementImpl classI1 = ElementFactory.classElement2("I1");
     String methodName = "m";
     MethodElement methodM1 =
         ElementFactory.methodElement(methodName, _typeProvider.intType);
     classI1.methods = <MethodElement>[methodM1];
@@ skipping 1229 matching lines @@
 }
 f(var a) {
   if(a is A) {
     return a.b;
   }
 }''');
     computeLibrarySourceErrors(source);
     assertNoErrors(source);
   }
 
+  void test_undefinedIdentifier_inComment_empty() {
+    Source source = addSource(r'''
+/// []
+main() {}
+''');
+    computeLibrarySourceErrors(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+
+  void fail_undefinedIdentifier_inComment_inCode() {
+    Source source = addSource(r'''
+/// Validate that every `a[i] == b[i]`.
+main(a, b) {}
+''');
+    computeLibrarySourceErrors(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+
+  void test_undefinedIdentifier_inComment_prefixed() {
+    Source source = addSource(r'''
+class Foo {
+  bar() {}
+  get baz => null;
+}
+/// [Foo.bar] and [Foo.baz]
+main() {}
+''');
+    computeLibrarySourceErrors(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+
+  void test_undefinedIdentifier_inComment_simple() {
+    Source source = addSource(r'''
+class Foo {}
+/// [Foo]
+main() {}
+''');
+    computeLibrarySourceErrors(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+
   void test_undefinedMethod_assignmentExpression_inSubtype() {
     Source source = addSource(r'''
 class A {}
 class B extends A {
   operator +(B b) {return new B();}
 }
 f(var a, var a2) {
   a = new A();
   a2 = new A();
   a += a2;
@@ skipping 2432 matching lines @@
     expect(classes, hasLength(1));
     List<ElementAnnotation> annotations = classes[0].metadata;
     expect(annotations, hasLength(1));
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     NodeList<CompilationUnitMember> declarations = unit.declarations;
     expect(declarations, hasLength(2));
     Element expectedElement = (declarations[0] as TopLevelVariableDeclaration)
         .variables
-        .variables[0].name.staticElement;
+        .variables[0]
+        .name
+        .staticElement;
     EngineTestCase.assertInstanceOf((obj) => obj is PropertyInducingElement,
         PropertyInducingElement, expectedElement);
     expectedElement = (expectedElement as PropertyInducingElement).getter;
     Element actualElement =
         (declarations[1] as ClassDeclaration).metadata[0].name.staticElement;
     expect(actualElement, same(expectedElement));
   }
 
   void test_metadata_field() {
     Source source = addSource(r'''
@@ skipping 170 matching lines @@
     expect(aliases, hasLength(1));
     List<ElementAnnotation> annotations = aliases[0].metadata;
     expect(annotations, hasLength(1));
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     NodeList<CompilationUnitMember> declarations = unit.declarations;
     expect(declarations, hasLength(2));
     Element expectedElement = (declarations[0] as TopLevelVariableDeclaration)
         .variables
-        .variables[0].name.staticElement;
+        .variables[0]
+        .name
+        .staticElement;
     EngineTestCase.assertInstanceOf((obj) => obj is PropertyInducingElement,
         PropertyInducingElement, expectedElement);
     expectedElement = (expectedElement as PropertyInducingElement).getter;
     Element actualElement =
         (declarations[1] as FunctionTypeAlias).metadata[0].name.staticElement;
     expect(actualElement, same(expectedElement));
   }
 
   void test_method_fromMixin() {
     Source source = addSource(r'''
@@ skipping 2202 matching lines @@
 }
 
 /**
  * Strong mode static analyzer downwards inference tests
  */
 @reflectiveTest
 class StrongModeDownwardsInferenceTest extends ResolverTestCase {
   TypeAssertions _assertions;
   AsserterBuilder<Element, DartType> _hasElement;
   AsserterBuilder<DartType, DartType> _isType;
-  AsserterBuilder2<Asserter<DartType>, Asserter<DartType>,
-      DartType> _isFunction2Of;
-  AsserterBuilderBuilder<Asserter<DartType>, List<Asserter<DartType>>,
-      DartType> _isInstantiationOf;
+  AsserterBuilder2<Asserter<DartType>, Asserter<DartType>, DartType>
+      _isFunction2Of;
+  AsserterBuilderBuilder<Asserter<DartType>, List<Asserter<DartType>>, DartType>
+      _isInstantiationOf;
   Asserter<DartType> _isInt;
   Asserter<DartType> _isNum;
   Asserter<DartType> _isString;
   Asserter<DartType> _isDynamic;
   AsserterBuilder<Asserter<DartType>, InterfaceType> _isListOf;
-  AsserterBuilder2<Asserter<DartType>, Asserter<DartType>,
-      InterfaceType> _isMapOf;
+  AsserterBuilder2<Asserter<DartType>, Asserter<DartType>, InterfaceType>
+      _isMapOf;
 
   @override
   void setUp() {
     AnalysisOptionsImpl options = new AnalysisOptionsImpl();
     options.strongMode = true;
     resetWithOptions(options);
     _assertions = new TypeAssertions(typeProvider);
     _isType = _assertions.isType;
     _hasElement = _assertions.hasElement;
     _isInstantiationOf = _assertions.isInstantiationOf;
@@ skipping 2210 matching lines @@
 import 'lib.dart';
 class B extends A {
   m() {
     return v; // marker
   }
 }''';
     _assertTypeOfMarkedExpression(
         code, typeProvider.dynamicType, typeProvider.intType);
   }
 
-  void test_finalPropertyInducingVariable_classMember_instance_propagatedTarget() {
+  void
+      test_finalPropertyInducingVariable_classMember_instance_propagatedTarget() {
     addNamedSource(
         "/lib.dart",
         r'''
 class A {
   final v = 0;
 }''');
     String code = r'''
 import 'lib.dart';
 f(p) {
   if (p is A) {
@@ skipping 198 matching lines @@
     FormalParameter kParameter = EngineTestCase.findNode(
         unit, code, "k, ", (node) => node is SimpleFormalParameter);
     expect(kParameter.identifier.propagatedType, same(intType));
     // v
     DartType stringType = typeProvider.stringType;
     FormalParameter vParameter = EngineTestCase.findNode(
         unit, code, "v)", (node) => node is SimpleFormalParameter);
     expect(vParameter.identifier.propagatedType, same(stringType));
   }
 
-  void test_functionExpression_asInvocationArgument_functionExpressionInvocation() {
+  void
+      test_functionExpression_asInvocationArgument_functionExpressionInvocation() {
     String code = r'''
 main() {
   (f(String value)) {} ((v) {
     v;
   });
 }''';
     Source source = addSource(code);
     LibraryElement library = resolve2(source);
     assertNoErrors(source);
     verify([source]);
@@ skipping 1857 matching lines @@
 
   void _resolveTestUnit(String code) {
     testCode = code;
     testSource = addSource(testCode);
     LibraryElement library = resolve2(testSource);
     assertNoErrors(testSource);
     verify([testSource]);
     testUnit = resolveCompilationUnit(testSource, library);
   }
 }