Add KernelNativeBehaviorComputer

pkg/compiler/lib/src/kernel/world_builder.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:kernel/ast.dart' as ir;
 
 import '../common.dart';
+import '../common/backend_api.dart';
 import '../common/names.dart';
+import '../compile_time_constants.dart';
+import '../constants/constant_system.dart';
+import '../constants/constructors.dart';
+import '../constants/evaluation.dart';
+import '../constants/expressions.dart';
+import '../constants/values.dart';
 import '../core_types.dart';
 import '../elements/elements.dart';
 import '../elements/entities.dart';
 import '../elements/types.dart';
+import '../js_backend/backend_helpers.dart';
+import '../js_backend/constant_system_javascript.dart';
 import '../native/native.dart' as native;
 import 'element_adapter.dart';
 import 'elements.dart';
 
 /// World builder used for creating elements and types corresponding to Kernel
 /// IR nodes.
 // TODO(johnniwinther): Implement [ResolutionWorldBuilder].
 class KernelWorldBuilder extends KernelElementAdapterMixin {
   CommonElements _commonElements;
+  native.BehaviorBuilder _nativeBehaviorBuilder;
   final DiagnosticReporter reporter;
-
+  ElementEnvironment _elementEnvironment;
   DartTypeConverter _typeConverter;
 
   /// Library environment. Used for fast lookup.
   KEnv _env;
 
   /// List of library environments by `KLibrary.libraryIndex`. This is used for
   /// fast lookup into library classes and members.
   List<KLibraryEnv> _libraryEnvs = <KLibraryEnv>[];
 
   /// List of class environments by `KClass.classIndex`. This is used for
   /// fast lookup into class members.
   List<KClassEnv> _classEnvs = <KClassEnv>[];
 
   Map<ir.Library, KLibrary> _libraryMap = <ir.Library, KLibrary>{};
   Map<ir.Class, KClass> _classMap = <ir.Class, KClass>{};
   Map<ir.TypeParameter, KTypeVariable> _typeVariableMap =
       <ir.TypeParameter, KTypeVariable>{};
+
   Map<ir.Member, KConstructor> _constructorMap = <ir.Member, KConstructor>{};
+  // TODO(johnniwinther): Change this to a list of 'KConstructorData' class
+  // holding the [ConstantConstructor] if we need more data for constructors.
+  List<ir.Member> _constructorList = <ir.Member>[];
+  Map<KConstructor, ConstantConstructor> _constructorConstantMap =
+      <KConstructor, ConstantConstructor>{};
+
   Map<ir.Procedure, KFunction> _methodMap = <ir.Procedure, KFunction>{};
   Map<ir.Field, KField> _fieldMap = <ir.Field, KField>{};
   Map<ir.TreeNode, KLocalFunction> _localFunctionMap =
       <ir.TreeNode, KLocalFunction>{};
 
   KernelWorldBuilder(this.reporter, ir.Program program)
       : _env = new KEnv(program) {
-    _commonElements =
-        new KernelCommonElements(new KernelElementEnvironment(this));
+    _elementEnvironment = new KernelElementEnvironment(this);
+    _commonElements = new KernelCommonElements(_elementEnvironment);
+    BackendHelpers helpers =
+        new BackendHelpers(_elementEnvironment, null, _commonElements);
+    ConstantEnvironment constants = new KernelConstantEnvironment(this);
+    _nativeBehaviorBuilder =
+        new KernelBehaviorBuilder(_commonElements, helpers, constants);
     _typeConverter = new DartTypeConverter(this);
   }
 
   CommonElements get commonElements => _commonElements;
 
+  ElementEnvironment get elementEnvironment => _elementEnvironment;
+
+  native.BehaviorBuilder get nativeBehaviorBuilder => _nativeBehaviorBuilder;
+
   LibraryEntity lookupLibrary(Uri uri) {
     KLibraryEnv libraryEnv = _env.lookupLibrary(uri);
     return _getLibrary(libraryEnv.library, libraryEnv);
   }
 
   KLibrary _getLibrary(ir.Library node, [KLibraryEnv libraryEnv]) {
     return _libraryMap.putIfAbsent(node, () {
       _libraryEnvs.add(libraryEnv ?? _env.lookupLibrary(node.importUri));
       String name = node.name;
       if (name == null) {
@@ skipping 66 matching lines @@
             return new KTypeVariable(_getMethod(procedure), node.name, index);
           }
         }
       }
       throw new UnsupportedError('Unsupported type parameter type node $node.');
     });
   }
 
   KConstructor _getConstructor(ir.Member node) {
     return _constructorMap.putIfAbsent(node, () {
+      int constructorIndex = _constructorList.length;
+      KConstructor constructor;
       if (node is ir.Constructor) {
-        return new KGenerativeConstructor(
+        constructor = new KGenerativeConstructor(constructorIndex,
             _getClass(node.enclosingClass), getName(node.name));
       } else {
-        return new KFactoryConstructor(
+        constructor = new KFactoryConstructor(constructorIndex,
             _getClass(node.enclosingClass), getName(node.name));
       }
+      _constructorList.add(node);
+      return constructor;
     });
   }
 
   KFunction _getMethod(ir.Procedure node) {
     return _methodMap.putIfAbsent(node, () {
       KClass enclosingClass =
           node.enclosingClass != null ? _getClass(node.enclosingClass) : null;
       Name name = getName(node.name);
       bool isStatic = node.isStatic;
       switch (node.kind) {
@@ skipping 66 matching lines @@
   List<DartType> getDartTypes(List<ir.DartType> types) {
     // TODO(johnniwinther): Add the type argument to the list literal when we
     // no longer use resolution types.
     List<DartType> list = /*<DartType>*/ [];
     types.forEach((ir.DartType type) {
       list.add(getDartType(type));
     });
     return list;
   }
 
-  @override
-  InterfaceType getThisType(ClassEntity cls) {
-    throw new UnimplementedError('KernelWorldBuilder.getThisType');
-  }
-
-  @override
-  InterfaceType getRawType(KClass cls) {
+  InterfaceType _getThisType(KClass cls) {
     KClassEnv env = _classEnvs[cls.classIndex];
     ir.Class node = env.cls;
     // TODO(johnniwinther): Add the type argument to the list literal when we
+    // no longer use resolution types.
+    return new InterfaceType(
+        cls,
+        new List/*<DartType>*/ .generate(node.typeParameters.length,
+            (int index) {
+          return new TypeVariableType(
+              _getTypeVariable(node.typeParameters[index]));
+        }));
+  }
+
+  InterfaceType _getRawType(KClass cls) {
+    KClassEnv env = _classEnvs[cls.classIndex];
+    ir.Class node = env.cls;
+    // TODO(johnniwinther): Add the type argument to the list literal when we
     // no longer use resolution types.
     return new InterfaceType(
         cls,
         new List/*<DartType>*/ .filled(
             node.typeParameters.length, const DynamicType()));
   }
 
   @override
-  native.NativeBehavior getNativeBehaviorForMethod(ir.Procedure procedure) {
-    throw new UnimplementedError(
-        'KernelWorldBuilder.getNativeBehaviorForMethod');
-  }
-
-  @override
-  native.NativeBehavior getNativeBehaviorForFieldStore(ir.Field field) {
-    throw new UnimplementedError(
-        'KernelWorldBuilder.getNativeBehaviorForFieldStore');
-  }
-
-  @override
-  native.NativeBehavior getNativeBehaviorForFieldLoad(ir.Field field) {
-    throw new UnimplementedError(
-        'KernelWorldBuilder.getNativeBehaviorForFieldLoad');
+  FunctionType getFunctionType(ir.FunctionNode node) {
+    DartType returnType = getDartType(node.returnType);
+    List<DartType> parameterTypes = /*<DartType>*/ [];
+    List<DartType> optionalParameterTypes = /*<DartType>*/ [];
+    for (ir.VariableDeclaration variable in node.positionalParameters) {
+      if (parameterTypes.length == node.requiredParameterCount) {
+        optionalParameterTypes.add(getDartType(variable.type));
+      } else {
+        parameterTypes.add(getDartType(variable.type));
+      }
+    }
+    List<String> namedParameters = <String>[];
+    List<DartType> namedParameterTypes = /*<DartType>*/ [];
+    List<ir.VariableDeclaration> sortedNamedParameters =
+        node.namedParameters.toList()..sort((a, b) => a.name.compareTo(b.name));
+    for (ir.VariableDeclaration variable in sortedNamedParameters) {
+      namedParameters.add(variable.name);
+      namedParameterTypes.add(getDartType(variable.type));
+    }
+    return new FunctionType(returnType, parameterTypes, optionalParameterTypes,
+        namedParameters, namedParameterTypes);
   }
 
   LibraryEntity getLibrary(ir.Library node) => _getLibrary(node);
 
   @override
   Local getLocalFunction(ir.TreeNode node) => _getLocal(node);
 
   @override
   ClassEntity getClass(ir.Class node) => _getClass(node);
 
@@ skipping 17 matching lines @@
         return _getConstructor(node);
       } else {
         return _getMethod(node);
       }
     }
     throw new UnsupportedError("Unexpected member: $node");
   }
 
   @override
   FunctionEntity getConstructor(ir.Member node) => _getConstructor(node);
+
+  ConstantConstructor _getConstructorConstant(KConstructor constructor) {
+    return _constructorConstantMap.putIfAbsent(constructor, () {
+      ir.Member node = _constructorList[constructor.constructorIndex];
+      if (node is ir.Constructor && node.isConst) {
+        return new Constantifier(this).computeConstantConstructor(node);
+      }
+      throw new SpannableAssertionFailure(constructor,
+          "Unexpected constructor $constructor in KernelWorldBuilder._getConstructorConstant");
+    });
+  }
 }
 
 /// Environment for fast lookup of program libraries.
 class KEnv {
   final ir.Program program;
 
   Map<Uri, KLibraryEnv> _libraryMap;
 
   KEnv(this.program);
 
@@ skipping 66 matching lines @@
         }
       }
       for (ir.Member member in cls.constructors) {
         _constructorMap[member.name.name] = member;
       }
     }
   }
 
   /// Return the [ir.Member] for the member [name] in [library].
   ir.Member lookupMember(String name, {bool setter: false}) {
+    _ensureMaps();
     return _memberMap[name];
   }
 
   /// Return the [ir.Member] for the member [name] in [library].
   ir.Member lookupConstructor(String name, {bool setter: false}) {
+    _ensureMaps();
     return _constructorMap[name];
   }
 }
 
 class KernelElementEnvironment implements ElementEnvironment {
   final KernelWorldBuilder worldBuilder;
 
   KernelElementEnvironment(this.worldBuilder);
 
   @override
   InterfaceType getThisType(ClassEntity cls) {
-    return worldBuilder.getThisType(cls);
+    return worldBuilder._getThisType(cls);
   }
 
   @override
   InterfaceType getRawType(ClassEntity cls) {
-    return worldBuilder.getRawType(cls);
+    return worldBuilder._getRawType(cls);
   }
 
   @override
   InterfaceType createInterfaceType(
       ClassEntity cls, List<DartType> typeArguments) {
     return new InterfaceType(cls, typeArguments);
   }
 
   @override
   ConstructorEntity lookupConstructor(ClassEntity cls, String name,
@@ skipping 155 matching lines @@
   DartType visitInvalidType(ir.InvalidType node) {
     if (topLevel) {
       throw new UnimplementedError(
           "Outermost invalid types not currently supported");
     }
     // Nested invalid types are treated as `dynamic`.
     return const DynamicType();
   }
 }
 
+/// [native.BehaviorBuilder] for kernel based elements.
+class KernelBehaviorBuilder extends native.BehaviorBuilder {
+  final CommonElements commonElements;
+  final BackendHelpers helpers;
+  final ConstantEnvironment constants;
+
+  KernelBehaviorBuilder(this.commonElements, this.helpers, this.constants);
+
+  @override
+  bool get trustJSInteropTypeAnnotations {
+    throw new UnimplementedError(
+        "KernelNativeBehaviorComputer.trustJSInteropTypeAnnotations");
+  }
+
+  @override
+  DiagnosticReporter get reporter {
+    throw new UnimplementedError("KernelNativeBehaviorComputer.reporter");
+  }
+
+  @override
+  BackendClasses get backendClasses {
+    throw new UnimplementedError("KernelNativeBehaviorComputer.backendClasses");
+  }
+}
+
+/// Constant environment mapping [ConstantExpression]s to [ConstantValue]s using
+/// [_EvaluationEnvironment] for the evaluation.
+class KernelConstantEnvironment implements ConstantEnvironment {
+  KernelWorldBuilder _worldBuilder;
+  Map<ConstantExpression, ConstantValue> _valueMap =
+      <ConstantExpression, ConstantValue>{};
+
+  KernelConstantEnvironment(this._worldBuilder);
+
+  @override
+  ConstantSystem get constantSystem => const JavaScriptConstantSystem();
+
+  @override
+  ConstantValue getConstantValueForVariable(VariableElement element) {
+    throw new UnimplementedError(
+        "KernelConstantEnvironment.getConstantValueForVariable");
+  }
+
+  @override
+  ConstantValue getConstantValue(ConstantExpression expression) {
+    return _valueMap.putIfAbsent(expression, () {
+      return expression.evaluate(
+          new _EvaluationEnvironment(_worldBuilder), constantSystem);
+    });
+  }
+
+  @override
+  bool hasConstantValue(ConstantExpression expression) {
+    throw new UnimplementedError("KernelConstantEnvironment.hasConstantValue");
+  }
+}
+
+/// Evaluation environment used for computing [ConstantValue]s for
+/// kernel based [ConstantExpression]s.
+class _EvaluationEnvironment implements Environment {
+  final KernelWorldBuilder _worldBuilder;
+
+  _EvaluationEnvironment(this._worldBuilder);
+
+  @override
+  CommonElements get commonElements {
+    throw new UnimplementedError("_EvaluationEnvironment.commonElements");
+  }
+
+  @override
+  BackendClasses get backendClasses {
+    throw new UnimplementedError("_EvaluationEnvironment.backendClasses");
+  }
+
+  @override
+  InterfaceType substByContext(InterfaceType base, InterfaceType target) {
+    if (base.typeArguments.isNotEmpty) {
+      throw new UnimplementedError("_EvaluationEnvironment.substByContext");
+    }
+    return base;
+  }
+
+  @override
+  ConstantConstructor getConstructorConstant(ConstructorEntity constructor) {
+    return _worldBuilder._getConstructorConstant(constructor);
+  }
+
+  @override
+  ConstantExpression getFieldConstant(FieldEntity field) {
+    throw new UnimplementedError("_EvaluationEnvironment.getFieldConstant");
+  }
+
+  @override
+  ConstantExpression getLocalConstant(Local local) {
+    throw new UnimplementedError("_EvaluationEnvironment.getLocalConstant");
+  }
+
+  @override
+  String readFromEnvironment(String name) {
+    throw new UnimplementedError("_EvaluationEnvironment.readFromEnvironment");
+  }
+}
+
 // Interface for testing equivalence of Kernel-based entities.
 class WorldDeconstructionForTesting {
   final KernelWorldBuilder builder;
 
   WorldDeconstructionForTesting(this.builder);
 
   Uri getLibraryUri(KLibrary library) {
     return builder._libraryEnvs[library.libraryIndex].library.importUri;
   }
 
@@ skipping 14 matching lines @@
     }
     return builder._getLibrary(library);
   }
 
   KLibrary getLibraryForFunction(KFunction function) =>
       _getLibrary(function, builder._methodMap);
 
   KLibrary getLibraryForField(KField field) =>
       _getLibrary(field, builder._fieldMap);
 }