Move LibraryUnitTarget into API.

pkg/analyzer/test/src/task/dart_test.dart

 // Copyright (c) 2015, 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 test.src.task.dart_test;
 
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/file_system/memory_file_system.dart';
 import 'package:analyzer/src/context/cache.dart';
 import 'package:analyzer/src/generated/ast.dart';
@@ skipping 145 matching lines @@
     expect(task, new isInstanceOf<BuildClassConstructorsTask>());
     _fillErrorListener(CONSTRUCTORS_ERRORS);
     errorListener.assertErrorsWithCodes(
         <ErrorCode>[CompileTimeErrorCode.MIXIN_HAS_NO_CONSTRUCTORS]);
   }
 }
 
 @reflectiveTest
 class BuildCompilationUnitElementTaskTest extends _AbstractDartTaskTest {
   test_buildInputs() {
-    LibraryUnitTarget target = new LibraryUnitTarget(emptySource, emptySource);
+    LibrarySpecificUnit target = new LibrarySpecificUnit(emptySource, emptySource);
     Map<String, TaskInput> inputs =
         BuildCompilationUnitElementTask.buildInputs(target);
     expect(inputs, isNotNull);
     expect(inputs.keys, unorderedEquals(
         [BuildCompilationUnitElementTask.PARSED_UNIT_INPUT_NAME]));
   }
 
   test_constructor() {
     BuildCompilationUnitElementTask task =
         new BuildCompilationUnitElementTask(context, emptySource);
@@ skipping 31 matching lines @@
 class B = Object with A;
 ''');
     expect(outputs, hasLength(3));
     expect(outputs[CLASS_ELEMENTS], hasLength(2));
     expect(outputs[COMPILATION_UNIT_ELEMENT], isNotNull);
     expect(outputs[RESOLVED_UNIT1], isNotNull);
   }
 
   void _performBuildTask(String content) {
     Source source = _newSource('/test.dart', content);
-    AnalysisTarget target = new LibraryUnitTarget(source, source);
+    AnalysisTarget target = new LibrarySpecificUnit(source, source);
     _computeResult(target, RESOLVED_UNIT1);
     expect(task, new isInstanceOf<BuildCompilationUnitElementTask>());
   }
 }
 
 @reflectiveTest
 class BuildDirectiveElementsTaskTest extends _AbstractDartTaskTest {
   test_constructor() {
     BuildDirectiveElementsTask task =
         new BuildDirectiveElementsTask(context, emptySource);
@@ skipping 42 matching lines @@
     _computeResult(sourceA, LIBRARY_ELEMENT2);
     expect(task, new isInstanceOf<BuildDirectiveElementsTask>());
     // prepare outputs
     LibraryElement libraryElementA = outputs[LIBRARY_ELEMENT2];
     LibraryElement libraryElementB = _getImportLibraryInput(sourceB);
     LibraryElement libraryElementC = _getExportLibraryInput(sourceC);
     // no errors
     _assertErrorsWithCodes([]);
     // validate directives
     CompilationUnit libraryUnitA = context
-        .getCacheEntry(new LibraryUnitTarget(sourceA, sourceA))
+        .getCacheEntry(new LibrarySpecificUnit(sourceA, sourceA))
         .getValue(RESOLVED_UNIT1);
     {
       ImportDirective importNode = libraryUnitA.directives[1];
       ImportElement importElement = importNode.element;
       expect(importElement, isNotNull);
       expect(importElement.importedLibrary, libraryElementB);
       expect(importElement.prefix, isNull);
       expect(importElement.nameOffset, 14);
       expect(importElement.uriOffset, 21);
       expect(importElement.uriEnd, 32);
@@ skipping 26 matching lines @@
       '/libB.dart': '''
 library libB;
 '''
     });
     Source sourceA = sources[0];
     // perform task
     _computeResult(sourceA, LIBRARY_ELEMENT2);
     expect(task, new isInstanceOf<BuildDirectiveElementsTask>());
     // prepare outputs
     CompilationUnit libraryUnitA = context
-        .getCacheEntry(new LibraryUnitTarget(sourceA, sourceA))
+        .getCacheEntry(new LibrarySpecificUnit(sourceA, sourceA))
         .getValue(RESOLVED_UNIT1);
     // no errors
     _assertErrorsWithCodes([]);
     // validate directives
     ImportDirective importNode = libraryUnitA.directives[1];
     ImportElement importElement = importNode.element;
     List<NamespaceCombinator> combinators = importElement.combinators;
     expect(combinators, hasLength(2));
     {
       ShowElementCombinator combinator = combinators[0];
@@ skipping 72 matching lines @@
 library libC;
 '''
     });
     Source sourceA = sources[0];
     Source sourceB = sources[1];
     // perform task
     _computeResult(sourceA, LIBRARY_ELEMENT2);
     expect(task, new isInstanceOf<BuildDirectiveElementsTask>());
     // prepare outputs
     CompilationUnit libraryUnitA = context
-        .getCacheEntry(new LibraryUnitTarget(sourceA, sourceA))
+        .getCacheEntry(new LibrarySpecificUnit(sourceA, sourceA))
         .getValue(RESOLVED_UNIT1);
     // validate directives
     {
       ImportDirective importNodeB = libraryUnitA.directives[1];
       SimpleIdentifier prefixNodeB = importNodeB.prefix;
       ImportElement importElementB = importNodeB.element;
       PrefixElement prefixElement = importElementB.prefix;
       expect(importElementB, isNotNull);
       expect(importElementB.importedLibrary, _getImportLibraryInput(sourceB));
       expect(prefixElement, isNotNull);
@@ skipping 25 matching lines @@
 }
 
 @reflectiveTest
 class BuildEnumMemberElementsTaskTest extends _AbstractDartTaskTest {
   test_perform() {
     Source source = _newSource('/test.dart', '''
 enum MyEnum {
   A, B
 }
 ''');
-    _computeResult(new LibraryUnitTarget(source, source), RESOLVED_UNIT2);
+    _computeResult(new LibrarySpecificUnit(source, source), RESOLVED_UNIT2);
     expect(task, new isInstanceOf<BuildEnumMemberElementsTask>());
     CompilationUnit unit = outputs[RESOLVED_UNIT2];
     // validate Element
     ClassElement enumElement = unit.element.getEnum('MyEnum');
     List<FieldElement> fields = enumElement.fields;
     expect(fields, hasLength(4));
     {
       FieldElementImpl index = fields[0];
       expect(index, isNotNull);
       expect(index.name, 'index');
@@ skipping 141 matching lines @@
   }
 }
 
 @reflectiveTest
 class BuildFunctionTypeAliasesTaskTest extends _AbstractDartTaskTest {
   test_perform() {
     Source source = _newSource('/test.dart', '''
 typedef int F(G g);
 typedef String G(int p);
 ''');
-    LibraryUnitTarget target = new LibraryUnitTarget(source, source);
+    LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     _computeResult(target, RESOLVED_UNIT3);
     expect(task, new isInstanceOf<BuildFunctionTypeAliasesTask>());
     // validate
     CompilationUnit unit = outputs[RESOLVED_UNIT3];
     FunctionTypeAlias nodeF = unit.declarations[0];
     FunctionTypeAlias nodeG = unit.declarations[1];
     {
       FormalParameter parameter = nodeF.parameters.parameters[0];
       DartType parameterType = parameter.element.type;
       Element returnTypeElement = nodeF.returnType.type.element;
       expect(returnTypeElement.displayName, 'int');
       expect(parameterType.element, nodeG.element);
     }
     {
       FormalParameter parameter = nodeG.parameters.parameters[0];
       DartType parameterType = parameter.element.type;
       expect(nodeG.returnType.type.element.displayName, 'String');
       expect(parameterType.element.displayName, 'int');
     }
   }
 
   test_perform_errors() {
     Source source = _newSource('/test.dart', '''
 typedef int F(NoSuchType p);
 ''');
-    LibraryUnitTarget target = new LibraryUnitTarget(source, source);
+    LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     _computeResult(target, BUILD_FUNCTION_TYPE_ALIASES_ERRORS);
     expect(task, new isInstanceOf<BuildFunctionTypeAliasesTask>());
     // validate
     _fillErrorListener(BUILD_FUNCTION_TYPE_ALIASES_ERRORS);
     errorListener
         .assertErrorsWithCodes(<ErrorCode>[StaticWarningCode.UNDEFINED_CLASS]);
   }
 }
 
 @reflectiveTest
@@ skipping 268 matching lines @@
     _fillErrorListener(BUILD_LIBRARY_ERRORS);
     errorListener.assertErrorsWithCodes(expectedErrorCodes);
   }
 
   void _performBuildTask(Map<String, String> sourceMap) {
     List<Source> sources = _newSources(sourceMap);
     Source libSource = sources.first;
     _computeResult(libSource, LIBRARY_ELEMENT1);
     expect(task, new isInstanceOf<BuildLibraryElementTask>());
     libraryUnit = context
-        .getCacheEntry(new LibraryUnitTarget(libSource, libSource))
+        .getCacheEntry(new LibrarySpecificUnit(libSource, libSource))
         .getValue(RESOLVED_UNIT1);
     libraryUnitElement = libraryUnit.element;
     librarySource = libraryUnitElement.source;
     libraryElement = outputs[LIBRARY_ELEMENT1];
     partUnits = task.inputs[BuildLibraryElementTask.PARTS_UNIT_INPUT];
   }
 }
 
 @reflectiveTest
 class BuildPublicNamespaceTaskTest extends _AbstractDartTaskTest {
@@ skipping 214 matching lines @@
 import 'b.dart';
 main() {
   new A();
 }''');
     _computeUsedElements(source);
     // validate
     expect(usedElementNames, unorderedEquals(['A']));
   }
 
   void _computeUsedElements(Source source) {
-    LibraryUnitTarget target = new LibraryUnitTarget(source, source);
+    LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     _computeResult(target, USED_IMPORTED_ELEMENTS);
     expect(task, new isInstanceOf<GatherUsedImportedElementsTask>());
     usedElements = outputs[USED_IMPORTED_ELEMENTS];
     usedElementNames = usedElements.elements.map((e) => e.name).toSet();
   }
 }
 
 @reflectiveTest
 class GatherUsedLocalElementsTaskTest extends _AbstractDartTaskTest {
   UsedLocalElements usedElements;
@@ skipping 23 matching lines @@
   p._m3();
 }
 ''');
     _computeUsedElements(source);
     // validate
     expect(usedElementNames, unorderedEquals(['A', 'a', 'p', '_m2']));
     expect(usedElements.members, unorderedEquals(['_m2', '_m3']));
   }
 
   void _computeUsedElements(Source source) {
-    LibraryUnitTarget target = new LibraryUnitTarget(source, source);
+    LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     _computeResult(target, USED_LOCAL_ELEMENTS);
     expect(task, new isInstanceOf<GatherUsedLocalElementsTask>());
     usedElements = outputs[USED_LOCAL_ELEMENTS];
     usedElementNames = usedElements.elements.map((e) => e.name).toSet();
   }
 }
 
 @reflectiveTest
 class GenerateHintsTaskTest extends _AbstractDartTaskTest {
   test_perform_bestPractices_missingReturn() {
     Source source = _newSource('/test.dart', '''
 int main() {
 }
 ''');
-    LibraryUnitTarget target = new LibraryUnitTarget(source, source);
+    LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     _computeResult(target, HINTS);
     expect(task, new isInstanceOf<GenerateHintsTask>());
     // validate
     _fillErrorListener(HINTS);
     errorListener.assertErrorsWithCodes(<ErrorCode>[HintCode.MISSING_RETURN]);
   }
 
   test_perform_dart2js() {
     Source source = _newSource('/test.dart', '''
 main(p) {
   if (p is double) {
     print('double');
   }
 }
 ''');
-    LibraryUnitTarget target = new LibraryUnitTarget(source, source);
+    LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     _computeResult(target, HINTS);
     expect(task, new isInstanceOf<GenerateHintsTask>());
     // validate
     _fillErrorListener(HINTS);
     errorListener.assertErrorsWithCodes(<ErrorCode>[HintCode.IS_DOUBLE]);
   }
 
   test_perform_deadCode() {
     Source source = _newSource('/test.dart', '''
 main() {
   if (false) {
     print('how?');
   }
 }
 ''');
-    LibraryUnitTarget target = new LibraryUnitTarget(source, source);
+    LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     _computeResult(target, HINTS);
     expect(task, new isInstanceOf<GenerateHintsTask>());
     // validate
     _fillErrorListener(HINTS);
     errorListener.assertErrorsWithCodes(<ErrorCode>[HintCode.DEAD_CODE]);
   }
 
   test_perform_imports_duplicateImport() {
     _newSource('/a.dart', r'''
 library lib_a;
 class A {}
 ''');
     Source source = _newSource('/test.dart', r'''
 import 'a.dart';
 import 'a.dart';
 main() {
   new A();
 }
 ''');
-    LibraryUnitTarget target = new LibraryUnitTarget(source, source);
+    LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     _computeResult(target, HINTS);
     expect(task, new isInstanceOf<GenerateHintsTask>());
     // validate
     _fillErrorListener(HINTS);
     errorListener.assertErrorsWithCodes(<ErrorCode>[HintCode.DUPLICATE_IMPORT]);
   }
 
   test_perform_imports_unusedImport_one() {
     _newSource('/a.dart', r'''
 library lib_a;
 class A {}
 ''');
     _newSource('/b.dart', r'''
 library lib_b;
 class B {}
 ''');
     Source source = _newSource('/test.dart', r'''
 import 'a.dart';
 import 'b.dart';
 main() {
   new A();
 }''');
-    LibraryUnitTarget target = new LibraryUnitTarget(source, source);
+    LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     _computeResult(target, HINTS);
     expect(task, new isInstanceOf<GenerateHintsTask>());
     // validate
     _fillErrorListener(HINTS);
     errorListener.assertErrorsWithCodes(<ErrorCode>[HintCode.UNUSED_IMPORT]);
   }
 
   test_perform_imports_unusedImport_zero() {
     _newSource('/a.dart', r'''
 library lib_a;
 class A {}
 ''');
     Source source = _newSource('/test.dart', r'''
 import 'a.dart';
 main() {
   new A();
 }''');
-    LibraryUnitTarget target = new LibraryUnitTarget(source, source);
+    LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     _computeResult(target, HINTS);
     expect(task, new isInstanceOf<GenerateHintsTask>());
     // validate
     _fillErrorListener(HINTS);
     errorListener.assertNoErrors();
   }
 
   test_perform_overrideVerifier() {
     Source source = _newSource('/test.dart', '''
 class A {}
 class B {
   @override
   m() {}
 }
 ''');
-    LibraryUnitTarget target = new LibraryUnitTarget(source, source);
+    LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     _computeResult(target, HINTS);
     expect(task, new isInstanceOf<GenerateHintsTask>());
     // validate
     _fillErrorListener(HINTS);
     errorListener.assertErrorsWithCodes(
         <ErrorCode>[HintCode.OVERRIDE_ON_NON_OVERRIDING_METHOD]);
   }
 
   test_perform_todo() {
     Source source = _newSource('/test.dart', '''
 main() {
   // TODO(developer) foo bar
 }
 ''');
-    LibraryUnitTarget target = new LibraryUnitTarget(source, source);
+    LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     _computeResult(target, HINTS);
     expect(task, new isInstanceOf<GenerateHintsTask>());
     // validate
     _fillErrorListener(HINTS);
     errorListener.assertErrorsWithCodes(<ErrorCode>[TodoCode.TODO]);
   }
 
   test_perform_unusedLocalElements_class() {
     Source source = _newSource('/test.dart', '''
 class _A {}
 class _B {}
 main() {
   new _A();
 }
 ''');
-    LibraryUnitTarget target = new LibraryUnitTarget(source, source);
+    LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     _computeResult(target, HINTS);
     expect(task, new isInstanceOf<GenerateHintsTask>());
     // validate
     _fillErrorListener(HINTS);
     errorListener.assertErrorsWithCodes(<ErrorCode>[HintCode.UNUSED_ELEMENT]);
   }
 
   test_perform_unusedLocalElements_localVariable() {
     Source source = _newSource('/test.dart', '''
 main() {
   var v = 42;
 }
 ''');
-    LibraryUnitTarget target = new LibraryUnitTarget(source, source);
+    LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     _computeResult(target, HINTS);
     expect(task, new isInstanceOf<GenerateHintsTask>());
     // validate
     _fillErrorListener(HINTS);
     errorListener
         .assertErrorsWithCodes(<ErrorCode>[HintCode.UNUSED_LOCAL_VARIABLE]);
   }
 
   test_perform_unusedLocalElements_method() {
     Source source = _newSource('/my_lib.dart', '''
 library my_lib;
 part 'my_part.dart';
 class A {
   _ma() {}
   _mb() {}
   _mc() {}
 }
 ''');
     _newSource('/my_part.dart', '''
 part of my_lib;
 
 f(A a) {
   a._mb();
 }
 ''');
-    LibraryUnitTarget target = new LibraryUnitTarget(source, source);
+    LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     _computeResult(target, HINTS);
     expect(task, new isInstanceOf<GenerateHintsTask>());
     // validate
     _fillErrorListener(HINTS);
     errorListener.assertErrorsWithCodes(
         <ErrorCode>[HintCode.UNUSED_ELEMENT, HintCode.UNUSED_ELEMENT]);
   }
 }
 
 @reflectiveTest
@@ skipping 165 matching lines @@
 class ResolveReferencesTaskTest extends _AbstractDartTaskTest {
   test_perform() {
     Source source = _newSource('/test.dart', '''
 class A {
   m() {}
 }
 main(A a) {
   a.m();
 }
 ''');
-    LibraryUnitTarget target = new LibraryUnitTarget(source, source);
+    LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     // prepare unit and "a.m()" invocation
     CompilationUnit unit;
     MethodInvocation invocation;
     {
       _computeResult(target, RESOLVED_UNIT1);
       unit = outputs[RESOLVED_UNIT1];
       // walk the AST
       FunctionDeclaration function = unit.declarations[1];
       BlockFunctionBody body = function.functionExpression.body;
       ExpressionStatement statement = body.block.statements[0];
@@ skipping 12 matching lines @@
   }
 
   test_perform_errors() {
     Source source = _newSource('/test.dart', '''
 class A {
 }
 main(A a) {
   a.unknownMethod();
 }
 ''');
-    LibraryUnitTarget target = new LibraryUnitTarget(source, source);
+    LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     _computeResult(target, RESOLVED_UNIT);
     expect(task, new isInstanceOf<ResolveReferencesTask>());
     // validate
     _fillErrorListener(RESOLVE_REFERENCES_ERRORS);
     errorListener.assertErrorsWithCodes(
         <ErrorCode>[StaticTypeWarningCode.UNDEFINED_METHOD]);
   }
 }
 
 @reflectiveTest
 class ResolveUnitTypeNamesTaskTest extends _AbstractDartTaskTest {
   test_perform() {
     Source source = _newSource('/test.dart', '''
 class A {}
 class B extends A {}
 int f(String p) => p.length;
 ''');
-    LibraryUnitTarget target = new LibraryUnitTarget(source, source);
+    LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     _computeResult(target, RESOLVED_UNIT4);
     expect(task, new isInstanceOf<ResolveUnitTypeNamesTask>());
     // validate
     CompilationUnit unit = outputs[RESOLVED_UNIT4];
     {
       ClassDeclaration nodeA = unit.declarations[0];
       ClassDeclaration nodeB = unit.declarations[1];
       DartType extendsType = nodeB.extendsClause.superclass.type;
       expect(extendsType, nodeA.element.type);
     }
     {
       FunctionDeclaration functionNode = unit.declarations[2];
       DartType returnType = functionNode.returnType.type;
       List<FormalParameter> parameters =
           functionNode.functionExpression.parameters.parameters;
       expect(returnType.displayName, 'int');
       expect(parameters[0].element.type.displayName, 'String');
     }
   }
 
   test_perform_errors() {
     Source source = _newSource('/test.dart', '''
 NoSuchClass f() => null;
 ''');
-    LibraryUnitTarget target = new LibraryUnitTarget(source, source);
+    LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     _computeResult(target, RESOLVE_TYPE_NAMES_ERRORS);
     expect(task, new isInstanceOf<ResolveUnitTypeNamesTask>());
     // validate
     _fillErrorListener(RESOLVE_TYPE_NAMES_ERRORS);
     errorListener
         .assertErrorsWithCodes(<ErrorCode>[StaticWarningCode.UNDEFINED_CLASS]);
   }
 }
 
 @reflectiveTest
@@ skipping 16 matching lines @@
   var v3 = 1;
   var v4 = 1;
   v2 = 2;
   v4 = 2;
   localFunction() {
     v3 = 3;
     v4 = 3;
   }
 }
 ''');
-    LibraryUnitTarget target = new LibraryUnitTarget(source, source);
+    LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     _computeResult(target, RESOLVED_UNIT5);
     expect(task, new isInstanceOf<ResolveVariableReferencesTask>());
     // validate
     CompilationUnit unit = outputs[RESOLVED_UNIT5];
     FunctionElement main = unit.element.functions[0];
     expectMutated(main.localVariables[0], isFalse, isFalse);
     expectMutated(main.localVariables[1], isFalse, isTrue);
     expectMutated(main.localVariables[2], isTrue, isTrue);
     expectMutated(main.localVariables[3], isTrue, isTrue);
   }
 
   test_perform_parameter() {
     Source source = _newSource('/test.dart', '''
 main(p1, p2, p3, p4) {
   p2 = 2;
   p4 = 2;
   localFunction() {
     p3 = 3;
     p4 = 3;
   }
 }
 ''');
-    LibraryUnitTarget target = new LibraryUnitTarget(source, source);
+    LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     _computeResult(target, RESOLVED_UNIT5);
     expect(task, new isInstanceOf<ResolveVariableReferencesTask>());
     // validate
     CompilationUnit unit = outputs[RESOLVED_UNIT5];
     FunctionElement main = unit.element.functions[0];
     expectMutated(main.parameters[0], isFalse, isFalse);
     expectMutated(main.parameters[1], isFalse, isTrue);
     expectMutated(main.parameters[2], isTrue, isTrue);
     expectMutated(main.parameters[3], isTrue, isTrue);
   }
@@ skipping 57 matching lines @@
 @reflectiveTest
 class VerifyUnitTaskTest extends _AbstractDartTaskTest {
   test_perform_verifyError() {
     Source source = _newSource('/test.dart', '''
 main() {
   if (42) {
     print('Not bool!');
   }
 }
 ''');
-    LibraryUnitTarget target = new LibraryUnitTarget(source, source);
+    LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     _computeResult(target, VERIFY_ERRORS);
     expect(task, new isInstanceOf<VerifyUnitTask>());
     // validate
     _fillErrorListener(VERIFY_ERRORS);
     errorListener.assertErrorsWithCodes(
         <ErrorCode>[StaticTypeWarningCode.NON_BOOL_CONDITION]);
   }
 }
 
 class _AbstractDartTaskTest extends EngineTestCase {
@@ skipping 97 matching lines @@
     return entryMap.putIfAbsent(target, () => new CacheEntry());
   }
 
   TimestampedData<String> getContents(Source source) => source.contents;
 
   noSuchMethod(Invocation invocation) {
     print('noSuchMethod: ${invocation.memberName}');
     return super.noSuchMethod(invocation);
   }
 }