Prepare inference test for kernel based inference

tests/compiler/dart2js/inference/inference_test_helper.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.
 
+import 'package:compiler/src/closure.dart';
 import 'package:compiler/src/common.dart';
 import 'package:compiler/src/compiler.dart';
+import 'package:compiler/src/diagnostics/diagnostic_listener.dart';
 import 'package:compiler/src/elements/elements.dart';
 import 'package:compiler/src/elements/entities.dart';
-import 'package:compiler/src/tree/nodes.dart';
+import 'package:compiler/src/tree/nodes.dart' as ast;
 import 'package:compiler/src/types/types.dart';
-
+import 'package:compiler/src/js_model/locals.dart';
+import 'package:compiler/src/kernel/element_map.dart';
+import 'package:compiler/src/kernel/kernel_backend_strategy.dart';
+import 'package:kernel/ast.dart' as ir;
 import '../equivalence/id_equivalence.dart';
 
 /// Compute type inference data for [_member] as a [MemberElement].
 ///
 /// Fills [actualMap] with the data and [sourceSpanMap] with the source spans
 /// for the data origin.
 void computeMemberAstTypeMasks(
     Compiler compiler, MemberEntity _member, Map<Id, ActualData> actualMap,
     {bool verbose: false}) {
   MemberElement member = _member;
   ResolvedAst resolvedAst = member.resolvedAst;
   if (resolvedAst.kind != ResolvedAstKind.PARSED) return;
   compiler.reporter.withCurrentElement(member.implementation, () {
     new TypeMaskComputer(compiler.reporter, actualMap, resolvedAst,
             compiler.globalInference.results)
         .run();
   });
 }
 
+abstract class ComputeValueMixin<T> {
+  GlobalTypeInferenceResults<T> get results;
+
+  String getMemberValue(MemberEntity member) {
+    GlobalTypeInferenceMemberResult<T> memberResult =
+        results.resultOfMember(member);
+    return getTypeMaskValue(
+        member.isFunction ? memberResult.returnType : memberResult.type);
+  }
+
+  String getParameterValue(Local parameter) {
+    GlobalTypeInferenceParameterResult<T> elementResult =
+        results.resultOfParameter(parameter);
+    return getTypeMaskValue(elementResult.type);
+  }
+
+  String getTypeMaskValue(TypeMask typeMask) {
+    return typeMask != null ? '$typeMask' : null;
+  }
+}
+
 /// AST visitor for computing inference data for a member.
-class TypeMaskComputer extends AstDataExtractor {
-  final GlobalTypeInferenceResults results;
-  final GlobalTypeInferenceElementResult result;
+class TypeMaskComputer extends AstDataExtractor
+    with ComputeValueMixin<ast.Node> {
+  final GlobalTypeInferenceResults<ast.Node> results;
+  final GlobalTypeInferenceElementResult<ast.Node> result;
 
   TypeMaskComputer(DiagnosticReporter reporter, Map<Id, ActualData> actualMap,
       ResolvedAst resolvedAst, this.results)
       : result = results.resultOfMember(resolvedAst.element as MemberElement),
         super(reporter, actualMap, resolvedAst);
 
   @override
   String computeElementValue(AstElement element) {
-    GlobalTypeInferenceElementResult elementResult;
     if (element.isParameter) {
       ParameterElement parameter = element;
-      elementResult = results.resultOfParameter(parameter);
+      return getParameterValue(parameter);
     } else if (element.isLocal) {
       LocalFunctionElement localFunction = element;
-      elementResult = results.resultOfMember(localFunction.callMethod);
+      return getMemberValue(localFunction.callMethod);
     } else {
       MemberElement member = element;
-      elementResult = results.resultOfMember(member);
+      return getMemberValue(member);
     }
-
-    TypeMask value =
-        element.isFunction ? elementResult.returnType : elementResult.type;
-    return value != null ? '$value' : null;
   }
 
   @override
-  String computeNodeValue(Node node, [AstElement element]) {
-    if (node is Send) {
-      TypeMask value = result.typeOfSend(node);
-      return value != null ? '$value' : null;
+  String computeNodeValue(ast.Node node, [AstElement element]) {
+    if (node is ast.Send) {
+      return getTypeMaskValue(result.typeOfSend(node));
     } else if (element != null && element.isLocal) {
       return computeElementValue(element);
     }
     return null;
   }
 }
+
+/// Compute type inference data for [member] from kernel based inference.
+///
+/// Fills [actualMap] with the data and [sourceSpanMap] with the source spans

[Siggi Cherem (dart-lang), 2017/08/25 00:23:46]

this was in the comment before too, but where is sourceSpanMap?

[Johnni Winther, 2017/08/25 07:44:25]

It was copied. Fix in both cases.

+/// for the data origin.
+void computeMemberIrTypeMasks(
+    Compiler compiler, MemberEntity member, Map<Id, ActualData> actualMap,
+    {bool verbose: false}) {
+  KernelBackendStrategy backendStrategy = compiler.backendStrategy;
+  KernelToElementMapForBuilding elementMap = backendStrategy.elementMap;
+  GlobalLocalsMap localsMap = backendStrategy.globalLocalsMapForTesting;
+  MemberDefinition definition = elementMap.getMemberDefinition(member);
+  new TypeMaskIrComputer(
+          actualMap,
+          elementMap,
+          member,
+          localsMap.getLocalsMap(member),
+          compiler.globalInference.results,
+          backendStrategy.closureDataLookup as ClosureDataLookup<ir.Node>)
+      .run(definition.node);
+}
+
+/// AST visitor for computing inference data for a member.
+class TypeMaskIrComputer extends IrDataExtractor
+    with ComputeValueMixin<ir.Node> {
+  final GlobalTypeInferenceResults<ir.Node> results;
+  final GlobalTypeInferenceElementResult<ir.Node> result;
+  final KernelToElementMapForBuilding _elementMap;
+  final KernelToLocalsMap _localsMap;
+  final ClosureDataLookup<ir.Node> _closureDataLookup;
+
+  TypeMaskIrComputer(
+      Map<Id, ActualData> actualMap,
+      this._elementMap,
+      MemberEntity member,
+      this._localsMap,
+      this.results,
+      this._closureDataLookup)
+      : result = results.resultOfMember(member),
+        super(actualMap);
+
+  @override
+  String computeMemberValue(ir.Member node) {
+    return getMemberValue(_elementMap.getMember(node));
+  }
+
+  @override
+  String computeNodeValue(ir.TreeNode node) {
+    if (node is ir.VariableDeclaration && node.parent is ir.FunctionNode) {
+      Local parameter = _localsMap.getLocalVariable(node);
+      return getParameterValue(parameter);
+    } else if (node is ir.FunctionExpression ||
+        node is ir.FunctionDeclaration) {
+      ClosureRepresentationInfo info = _closureDataLookup.getClosureInfo(node);
+      return getMemberValue(info.callMethod);
+    } else if (node is ir.MethodInvocation) {
+      return getTypeMaskValue(result.typeOfSend(node));
+    }
+    return null;
+  }
+}