Resynthesize expressions for Kernel's StaticGet and PropertyGet.

pkg/analyzer/test/src/summary/resynthesize_kernel_test.dart

 // Copyright (c) 2017, 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.src.summary.resynthesize_kernel_test;
 
 import 'dart:async';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/standard_ast_factory.dart';
+import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/file_system/memory_file_system.dart';
 import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/dart/element/type.dart';
 import 'package:analyzer/src/generated/engine.dart' show AnalysisContext;
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/testing/ast_test_factory.dart';
 import 'package:analyzer/src/summary/resynthesize.dart';
 import 'package:front_end/file_system.dart';
@@ skipping 14 matching lines @@
   defineReflectiveSuite(() {
     defineReflectiveTests(ResynthesizeKernelStrongTest);
   });
 }
 
 @reflectiveTest
 class ResynthesizeKernelStrongTest extends ResynthesizeTest {
   final resourceProvider = new MemoryResourceProvider(context: pathos.posix);
 
   @override
+  bool get isSharedFrontEnd => true;
+
+  @override
   bool get isStrongMode => true;
 
   @override
   Source addLibrarySource(String path, String content) {
     path = resourceProvider.convertPath(path);
     File file = resourceProvider.newFile(path, content);
     return file.createSource();
   }
 
   @override
@@ skipping 162 matching lines @@
   test_class_documented_tripleSlash() async {
     await super.test_class_documented_tripleSlash();
   }
 
   @failingTest
   test_class_documented_withLeadingNotDocumentation() async {
     await super.test_class_documented_withLeadingNotDocumentation();
   }
 
   @failingTest
-  test_class_field_const() async {
-    await super.test_class_field_const();
-  }
-
-  @failingTest
   test_class_interfaces_unresolved() async {
     await super.test_class_interfaces_unresolved();
   }
 
   @failingTest
   test_class_mixins() async {
     await super.test_class_mixins();
   }
 
   @failingTest
@@ skipping 157 matching lines @@
   test_const_invokeConstructor_unnamed_unresolved2() async {
     await super.test_const_invokeConstructor_unnamed_unresolved2();
   }
 
   @failingTest
   test_const_invokeConstructor_unnamed_unresolved3() async {
     await super.test_const_invokeConstructor_unnamed_unresolved3();
   }
 
   @failingTest
-  test_const_length_ofClassConstField() async {
-    await super.test_const_length_ofClassConstField();
-  }
-
-  @failingTest
   test_const_length_ofClassConstField_imported() async {
     await super.test_const_length_ofClassConstField_imported();
   }
 
   @failingTest
   test_const_length_ofClassConstField_imported_withPrefix() async {
     await super.test_const_length_ofClassConstField_imported_withPrefix();
   }
 
   @failingTest
-  test_const_length_ofStringLiteral() async {
-    await super.test_const_length_ofStringLiteral();
-  }
-
-  @failingTest
-  test_const_length_ofTopLevelVariable() async {
-    await super.test_const_length_ofTopLevelVariable();
-  }
-
-  @failingTest
   test_const_length_ofTopLevelVariable_imported() async {
     await super.test_const_length_ofTopLevelVariable_imported();
   }
 
   @failingTest
   test_const_length_ofTopLevelVariable_imported_withPrefix() async {
     await super.test_const_length_ofTopLevelVariable_imported_withPrefix();
   }
 
   @failingTest
@@ skipping 533 matching lines @@
   test_field_documented() async {
     await super.test_field_documented();
   }
 
   @failingTest
   test_field_formal_param_inferred_type_implicit() async {
     await super.test_field_formal_param_inferred_type_implicit();
   }
 
   @failingTest
-  test_field_propagatedType_const_noDep() async {
-    await super.test_field_propagatedType_const_noDep();
-  }
-
-  @failingTest
   test_field_propagatedType_final_dep_inLib() async {
     await super.test_field_propagatedType_final_dep_inLib();
   }
 
   @failingTest
   test_field_propagatedType_final_dep_inPart() async {
     await super.test_field_propagatedType_final_dep_inPart();
   }
 
   @failingTest
@@ skipping 1163 matching lines @@
   @failingTest
   test_variable_setterInPart_getterInPart() async {
     await super.test_variable_setterInPart_getterInPart();
   }
 }
 
 /**
  * Builder of [Expression]s from [kernel.Expression]s.
  */
 class _ExprBuilder {
+  final _KernelLibraryResynthesizerContextImpl _context;
+
+  _ExprBuilder(this._context);
+
   Expression build(kernel.Expression expr) {
     if (expr is kernel.NullLiteral) {
       return AstTestFactory.nullLiteral();
     }
     if (expr is kernel.BoolLiteral) {
       return AstTestFactory.booleanLiteral(expr.value);
     }
     if (expr is kernel.IntLiteral) {
       return AstTestFactory.integer(expr.value);
     }
     if (expr is kernel.DoubleLiteral) {
       return AstTestFactory.doubleLiteral(expr.value);
     }
     if (expr is kernel.StringLiteral) {
       return AstTestFactory.string2(expr.value);
     }
     if (expr is kernel.StringConcatenation) {
       List<InterpolationElement> elements = expr.expressions
           .map(build)
           .map(_newInterpolationElement)
           .toList(growable: false);
       return AstTestFactory.string(elements);
     }
     if (expr is kernel.SymbolLiteral) {
       List<String> components = expr.value.split('.').toList();
       return AstTestFactory.symbolLiteral(components);
     }
+    if (expr is kernel.StaticGet) {
+      kernel.Reference reference = expr.targetReference;
+      Element element = _getElement(reference);
+      if (element is PropertyInducingElement) {
+        element = (element as PropertyInducingElement).getter;
+      }
+      SimpleIdentifier identifier =
+          AstTestFactory.identifier3(reference.canonicalName.name);
+      identifier.staticElement = element;
+      return identifier;
+    }
+    if (expr is kernel.PropertyGet) {
+      Expression target = build(expr.receiver);
+      SimpleIdentifier identifier = AstTestFactory.identifier3(expr.name.name);
+      ElementImpl element = _getElement(expr.interfaceTargetReference);
+      identifier.staticElement = element;
+      return AstTestFactory.propertyAccess(target, identifier);
+    }
     // TODO(scheglov): complete getExpression
-    throw new UnimplementedError('kernel: $expr');
+    throw new UnimplementedError('kernel: (${expr.runtimeType}) $expr');
+  }
+
+  ElementImpl _getElement(kernel.Reference reference) {
+    return _context._getElement(reference?.canonicalName);
   }
 
   InterpolationElement _newInterpolationElement(Expression expr) {
     if (expr is SimpleStringLiteral) {
       return astFactory.interpolationString(expr.literal, expr.value);
     } else {
       return AstTestFactory.interpolationExpression(expr);
     }
   }
 }
@@ skipping 47 matching lines @@
     implements KernelLibraryResynthesizerContext {
   final _KernelResynthesizer _resynthesizer;
 
   @override
   final kernel.Library library;
 
   _KernelLibraryResynthesizerContextImpl(this._resynthesizer, this.library);
 
   @override
   Expression getExpression(kernel.Expression expression) {
-    return new _ExprBuilder().build(expression);
+    return new _ExprBuilder(this).build(expression);
   }
 
   @override
   InterfaceType getInterfaceType(
       ElementImpl context, kernel.Supertype kernelType) {
     return _getInterfaceType(
         kernelType.className.canonicalName, kernelType.typeArguments);
   }
 
   DartType getType(ElementImpl context, kernel.DartType kernelType) {
     if (kernelType is kernel.DynamicType) return DynamicTypeImpl.instance;
     if (kernelType is kernel.InterfaceType) {
       return _getInterfaceType(
           kernelType.className.canonicalName, kernelType.typeArguments);
     }
     if (kernelType is kernel.VoidType) return VoidTypeImpl.instance;
     // TODO(scheglov) Support other kernel types.
     throw new UnimplementedError('For ${kernelType.runtimeType}');
   }
 
+  /**
+   * Return the [ElementImpl] that corresponds to the given [name], or `null`
+   * if the corresponding element cannot be found.
+   */
+  ElementImpl _getElement(kernel.CanonicalName name) {
+    if (name == null) return null;
+    kernel.CanonicalName parentName = name.parent;
+
+    // If the parent is the root, then this name is a library.
+    if (parentName.isRoot) {
+      return _resynthesizer.getLibrary(name.name);
+    }
+
+    // Skip qualifiers.
+    bool isGetter = false;
+    bool isSetter = false;
+    bool isField = false;
+    if (parentName.name == '@getters') {
+      isGetter = true;
+      parentName = parentName.parent;
+    } else if (parentName.name == '@setters') {
+      isSetter = true;
+      parentName = parentName.parent;
+    } else if (parentName.name == '@fields') {
+      isField = true;
+      parentName = parentName.parent;
+    }
+
+    ElementImpl parentElement = _getElement(parentName);
+    if (parentElement == null) return null;
+
+    // Search in units of the library.
+    if (parentElement is LibraryElementImpl) {
+      for (CompilationUnitElement unit in parentElement.units) {
+        CompilationUnitElementImpl unitImpl = unit;
+        ElementImpl child = unitImpl.getChild(name.name);
+        if (child != null) {
+          return child;
+        }
+      }
+      return null;
+    }
+
+    // Search in the class.
+    if (parentElement is ClassElementImpl) {
+      if (isGetter) {
+        return parentElement.getGetter(name.name) as ElementImpl;
+      } else if (isSetter) {
+        return parentElement.getSetter(name.name) as ElementImpl;
+      } else if (isField) {
+        return parentElement.getField(name.name) as ElementImpl;
+      }
+      return null;
+    }
+
+    throw new UnimplementedError('Should not be reached.');
+  }
+
   InterfaceType _getInterfaceType(
       kernel.CanonicalName className, List<kernel.DartType> kernelArguments) {
     var libraryName = className.parent;
     var libraryElement = _resynthesizer.getLibrary(libraryName.name);
     ClassElementImpl classElement = libraryElement.getType(className.name);
 
     if (kernelArguments.isEmpty) {
       return classElement.type;
     }
 
     return new InterfaceTypeImpl.elementWithNameAndArgs(
         classElement, classElement.name, () {
       List<DartType> arguments = kernelArguments
           .map((kernel.DartType k) => getType(classElement, k))
           .toList(growable: false);
       return arguments;
     });
   }
 }
 
 class _KernelResynthesizer {
   final AnalysisContext _analysisContext;
   final Map<String, kernel.Library> _kernelMap;
   final Map<String, LibraryElementImpl> _libraryMap = {};
 
+  /**
+   * Cache of [Source] objects that have already been converted from URIs.
+   */
+  final Map<String, Source> _sources = <String, Source>{};
+
   _KernelResynthesizer(this._analysisContext, this._kernelMap);
 
   LibraryElementImpl getLibrary(String uriStr) {
     return _libraryMap.putIfAbsent(uriStr, () {
       var kernel = _kernelMap[uriStr];
       if (kernel == null) return null;
+
       var libraryContext =
           new _KernelLibraryResynthesizerContextImpl(this, kernel);
-      return new LibraryElementImpl.forKernel(_analysisContext, libraryContext);
+      Source librarySource = _getSource(uriStr);
+      LibraryElementImpl libraryElement =
+          new LibraryElementImpl.forKernel(_analysisContext, libraryContext);
+      CompilationUnitElementImpl definingUnit =
+          libraryElement.definingCompilationUnit;
+      definingUnit.source = librarySource;
+      definingUnit.librarySource = librarySource;
+      return libraryElement;
     });
   }
+
+  /**
+   * Get the [Source] object for the given [uri].
+   */
+  Source _getSource(String uri) {
+    return _sources.putIfAbsent(
+        uri, () => _analysisContext.sourceFactory.forUri(uri));
+  }
 }