Resynthesize binary, prefix, and conditional expressions from Kernel.

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/ast/token.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';
 import 'package:front_end/src/base/performace_logger.dart';
 import 'package:front_end/src/fasta/uri_translator_impl.dart';
 import 'package:front_end/src/incremental/byte_store.dart';
 import 'package:front_end/src/incremental/kernel_driver.dart';
 import 'package:kernel/kernel.dart' as kernel;
 import 'package:kernel/target/targets.dart';
+import 'package:kernel/type_environment.dart' as kernel;
 import 'package:package_config/packages.dart';
 import 'package:path/path.dart' as pathos;
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
 import '../context/mock_sdk.dart';
 import 'resynthesize_common.dart';
 
 main() {
   defineReflectiveSuite(() {
     defineReflectiveTests(ResynthesizeKernelStrongTest);
@@ skipping 50 matching lines @@
     KernelResult kernelResult = await driver.getKernel(testUri);
 
     var libraryMap = <String, kernel.Library>{};
     for (var cycleResult in kernelResult.results) {
       for (var library in cycleResult.kernelLibraries) {
         String uriStr = library.importUri.toString();
         libraryMap[uriStr] = library;
       }
     }
 
-    var resynthesizer = new _KernelResynthesizer(context, libraryMap);
+    var resynthesizer =
+        new _KernelResynthesizer(context, kernelResult.types, libraryMap);
     return resynthesizer.getLibrary(testUriStr);
   }
 
   @override
   SummaryResynthesizer encodeDecodeLibrarySource(Source librarySource) {
     // TODO(scheglov): implement encodeDecodeLibrarySource
     throw new UnimplementedError();
   }
 
   @failingTest
@@ skipping 376 matching lines @@
   test_const_reference_topLevelFunction_imported() async {
     await super.test_const_reference_topLevelFunction_imported();
   }
 
   @failingTest
   test_const_reference_topLevelFunction_imported_withPrefix() async {
     await super.test_const_reference_topLevelFunction_imported_withPrefix();
   }
 
   @failingTest
-  test_const_reference_topLevelVariable() async {
-    await super.test_const_reference_topLevelVariable();
-  }
-
-  @failingTest
   test_const_reference_topLevelVariable_imported() async {
     await super.test_const_reference_topLevelVariable_imported();
   }
 
   @failingTest
   test_const_reference_topLevelVariable_imported_withPrefix() async {
     await super.test_const_reference_topLevelVariable_imported_withPrefix();
   }
 
   @failingTest
@@ skipping 30 matching lines @@
   test_const_reference_unresolved_prefix1() async {
     await super.test_const_reference_unresolved_prefix1();
   }
 
   @failingTest
   test_const_reference_unresolved_prefix2() async {
     await super.test_const_reference_unresolved_prefix2();
   }
 
   @failingTest
-  test_const_topLevel_binary() async {
-    await super.test_const_topLevel_binary();
-  }
-
-  @failingTest
-  test_const_topLevel_conditional() async {
-    await super.test_const_topLevel_conditional();
-  }
-
-  @failingTest
-  test_const_topLevel_identical() async {
-    await super.test_const_topLevel_identical();
-  }
-
-  @failingTest
-  test_const_topLevel_ifNull() async {
+  solo_test_const_topLevel_ifNull() async {
     await super.test_const_topLevel_ifNull();
   }
 
   @failingTest
-  test_const_topLevel_prefix() async {
-    await super.test_const_topLevel_prefix();
-  }
-
-  @failingTest
   test_const_topLevel_super() async {
     await super.test_const_topLevel_super();
   }
 
   @failingTest
   test_const_topLevel_this() async {
     await super.test_const_topLevel_this();
   }
 
   @failingTest
@@ skipping 1596 matching lines @@
       return _buildIdentifier(expr.targetReference, isGet: true);
     }
 
     if (expr is kernel.PropertyGet) {
       Expression target = build(expr.receiver);
       kernel.Reference reference = expr.interfaceTargetReference;
       SimpleIdentifier identifier = _buildSimpleIdentifier(reference);
       return AstTestFactory.propertyAccess(target, identifier);
     }
 
+    if (expr is kernel.ConditionalExpression) {
+      var condition = build(expr.condition);
+      var then = build(expr.then);
+      var otherwise = build(expr.otherwise);
+      return AstTestFactory.conditionalExpression(condition, then, otherwise);
+    }
+
+    if (expr is kernel.Not) {
+      kernel.Expression kernelOperand = expr.operand;
+      var operand = build(kernelOperand);
+      return AstTestFactory.prefixExpression(TokenType.BANG, operand);
+    }
+
+    if (expr is kernel.LogicalExpression) {
+      var operator = _toBinaryOperatorTokenType(expr.operator);
+      var left = build(expr.left);
+      var right = build(expr.right);
+      return AstTestFactory.binaryExpression(left, operator, right);
+    }
+
+    if (expr is kernel.MethodInvocation) {
+      kernel.Member member = expr.interfaceTarget;
+      if (member is kernel.Procedure) {
+        if (member.kind == kernel.ProcedureKind.Operator) {
+          var left = build(expr.receiver);
+          String operatorName = expr.name.name;
+          List<kernel.Expression> args = expr.arguments.positional;
+          if (args.isEmpty) {
+            if (operatorName == 'unary-') {
+              return AstTestFactory.prefixExpression(TokenType.MINUS, left);
+            }
+            if (operatorName == '~') {
+              return AstTestFactory.prefixExpression(TokenType.TILDE, left);
+            }
+          } else if (args.length == 1) {
+            var operator = _toBinaryOperatorTokenType(operatorName);
+            var right = build(args.single);
+            return AstTestFactory.binaryExpression(left, operator, right);
+          }
+        }
+      }
+    }
+
     // TODO(scheglov): complete getExpression
     throw new UnimplementedError('kernel: (${expr.runtimeType}) $expr');
   }
 
   Expression _buildIdentifier(kernel.Reference reference, {bool isGet: false}) {
     Element element = _getElement(reference);
     if (isGet && element is PropertyInducingElement) {
       element = (element as PropertyInducingElement).getter;
     }
     SimpleIdentifier property = AstTestFactory.identifier3(element.displayName)
@@ skipping 55 matching lines @@
     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);
     }
   }
+
+  /// Return the [TokenType] for the given operator [name].
+  TokenType _toBinaryOperatorTokenType(String name) {
+    if (name == '==') return TokenType.EQ_EQ;
+    if (name == '&&') return TokenType.AMPERSAND_AMPERSAND;
+    if (name == '||') return TokenType.BAR_BAR;
+    if (name == '^') return TokenType.CARET;
+    if (name == '&') return TokenType.AMPERSAND;
+    if (name == '|') return TokenType.BAR;
+    if (name == '>>') return TokenType.GT_GT;
+    if (name == '<<') return TokenType.LT_LT;
+    if (name == '+') return TokenType.PLUS;
+    if (name == '-') return TokenType.MINUS;
+    if (name == '*') return TokenType.STAR;
+    if (name == '/') return TokenType.SLASH;
+    if (name == '~/') return TokenType.TILDE_SLASH;
+    if (name == '%') return TokenType.PERCENT;
+    if (name == '>') return TokenType.GT;
+    if (name == '<') return TokenType.LT;
+    if (name == '>=') return TokenType.GT_EQ;
+    if (name == '<=') return TokenType.LT_EQ;
+    if (name == 'unary-') return TokenType.MINUS;
+    throw new ArgumentError(name);
+  }
 }
 
 class _FileSystemAdaptor implements FileSystem {
   final ResourceProvider provider;
 
   _FileSystemAdaptor(this.provider);
 
   @override
   FileSystemEntity entityForUri(Uri uri) {
     if (uri.isScheme('file')) {
@@ skipping 75 matching lines @@
 
     // 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;
+    bool isMethod = 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;
+    } else if (parentName.name == '@methods') {
+      isMethod = 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;
+      } else if (isMethod) {
+        return parentElement.getMethod(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 kernel.TypeEnvironment types;
   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);
+  _KernelResynthesizer(this._analysisContext, this.types, 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);
       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));
   }
 }