Add kernel/closed_world2_test

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.
 
 library dart2js.kernel.world_builder;
 
 import 'package:kernel/ast.dart' as ir;
 
 import '../common.dart';
 import '../common/backend_api.dart';
+import '../common/resolution.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 '../common_elements.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 '../js_backend/no_such_method_registry.dart';
 import '../native/native.dart' as native;
 import '../native/resolver.dart';
+import '../ssa/kernel_impact.dart';
 import '../universe/call_structure.dart';
 import 'element_adapter.dart';
 import 'elements.dart';
 
 part 'native_class_resolver.dart';
 part 'no_such_method_resolver.dart';
 
 /// World builder used for creating elements and types corresponding to Kernel
 /// IR nodes.
 // TODO(johnniwinther): Implement [ResolutionWorldBuilder].
@@ skipping 273 matching lines @@
         if (parent is ir.FunctionDeclaration ||
             parent is ir.FunctionExpression) {
           KLocalFunction localFunction = _getLocal(parent);
           executableContext = localFunction;
           memberContext = localFunction.memberContext;
           break;
         }
         parent = parent.parent;
       }
       String name;
+      FunctionType functionType;
       if (node is ir.FunctionDeclaration) {
         name = node.variable.name;
+        functionType = getFunctionType(node.function);
+      } else if (node is ir.FunctionExpression) {
+        functionType = getFunctionType(node.function);
       }
-      return new KLocalFunction(name, memberContext, executableContext);
+      return new KLocalFunction(
+          name, memberContext, executableContext, functionType);
     });
   }
 
   @override
   DartType getDartType(ir.DartType type) => _typeConverter.convert(type);
 
   @override
   InterfaceType createInterfaceType(
       ir.Class cls, List<ir.DartType> typeArguments) {
     return new InterfaceType(getClass(cls), getDartTypes(typeArguments));
   }
 
   @override
   InterfaceType getInterfaceType(ir.InterfaceType type) =>
       _typeConverter.convert(type);
 
   @override
   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;
   }
 
+  void _ensureThisAndRawType(KClass cls, KClassEnv env) {
+    if (env.thisType == null) {
+      ir.Class node = env.cls;
+      // TODO(johnniwinther): Add the type argument to the list literal when we
+      // no longer use resolution types.
+      if (node.typeParameters.isEmpty) {
+        env.thisType =
+            env.rawType = new InterfaceType(cls, const/*<DartType>*/ []);
+      } else {
+        env.thisType = new InterfaceType(
+            cls,
+            new List/*<DartType>*/ .generate(node.typeParameters.length,
+                (int index) {
+              return new TypeVariableType(
+                  _getTypeVariable(node.typeParameters[index]));
+            }));
+        env.rawType = new InterfaceType(
+            cls,
+            new List/*<DartType>*/ .filled(
+                node.typeParameters.length, const DynamicType()));
+      }
+    }
+  }
+
   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]));
-        }));
+    _ensureThisAndRawType(cls, env);
+    return env.thisType;
   }
 
   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()));
+    _ensureThisAndRawType(cls, env);
+    return env.rawType;
+  }
+
+  void _ensureSupertypes(KClass cls, KClassEnv env) {
+    if (env.supertypes == null) {
+      _ensureThisAndRawType(cls, env);
+
+      ir.Class node = env.cls;
+
+      Set<InterfaceType> supertypes = new Set<InterfaceType>();
+
+      InterfaceType addSupertype(ir.Supertype node) {
+        if (node == null) return null;
+        InterfaceType type = _typeConverter.visitSupertype(node);
+        KClass superclass = type.element;
+        KClassEnv env = _classEnvs[superclass.classIndex];
+        _ensureSupertypes(superclass, env);
+        for (InterfaceType supertype in env.supertypes) {
+          supertypes.add(
+              supertype.subst(type.typeArguments, env.thisType.typeArguments));
+        }
+        return type;
+      }
+
+      env.supertype = addSupertype(node.supertype);
+      addSupertype(node.mixedInType);
+      node.implementedTypes.forEach(addSupertype);
+
+      env.supertypes = supertypes.toList();
+    }
+  }
+
+  InterfaceType _getSuperType(KClass cls) {
+    KClassEnv env = _classEnvs[cls.classIndex];
+    _ensureSupertypes(cls, env);
+    return env.supertype;
+  }
+
+  void _forEachSupertype(KClass cls, void f(InterfaceType supertype)) {
+    KClassEnv env = _classEnvs[cls.classIndex];
+    _ensureSupertypes(cls, env);
+    env.supertypes.forEach(f);
   }
 
   @override
   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));
@@ skipping 67 matching lines @@
       ir.Field node = _memberList[field.memberIndex];
       if (node.isConst) {
         return new Constantifier(this).visit(node.initializer);
       }
       throw new SpannableAssertionFailure(
           field,
           "Unexpected field $field in "
           "KernelWorldBuilder._getConstructorConstant");
     });
   }
+
+  ResolutionImpact computeWorldImpact(KMember member) {
+    ir.Member node = _memberList[member.memberIndex];
+    return buildKernelImpact(node, this);
+  }
 }
 
 /// Environment for fast lookup of program libraries.
 class KEnv {
   final ir.Program program;
 
   Map<Uri, KLibraryEnv> _libraryMap;
 
   KEnv(this.program);
 
@@ skipping 41 matching lines @@
     }
     return _memberMap[name];
   }
 }
 
 /// Environment for fast lookup of class members.
 // TODO(johnniwinther): Add member lookup.
 class KClassEnv {
   final ir.Class cls;
 
+  InterfaceType thisType;
+  InterfaceType rawType;
+  InterfaceType supertype;
+  List<InterfaceType> supertypes;
+
   Map<String, ir.Member> _constructorMap;
   Map<String, ir.Member> _memberMap;
 
   KClassEnv(this.cls);
 
   void _ensureMaps() {
     if (_memberMap == null) {
       _memberMap = <String, ir.Member>{};
       _constructorMap = <String, ir.Member>{};
       for (ir.Member member in cls.members) {
@@ skipping 31 matching lines @@
   @override
   DartType get dynamicType => const DynamicType();
 
   @override
   LibraryEntity get mainLibrary => worldBuilder._mainLibrary;
 
   @override
   FunctionEntity get mainFunction => worldBuilder._mainFunction;
 
   @override
+  Iterable<LibraryEntity> get libraries => worldBuilder._libraryMap.values;
+
+  @override
   InterfaceType getThisType(ClassEntity cls) {
     return worldBuilder._getThisType(cls);
   }
 
   @override
   InterfaceType getRawType(ClassEntity cls) {
     return worldBuilder._getRawType(cls);
   }
 
   @override
   DartType getTypeVariableBound(TypeVariableEntity typeVariable) {
     throw new UnimplementedError(
         'KernelElementEnvironment.getTypeVariableBound');
   }
 
   @override
   InterfaceType createInterfaceType(
       ClassEntity cls, List<DartType> typeArguments) {
     return new InterfaceType(cls, typeArguments);
   }
 
   @override
   bool isSubtype(DartType a, DartType b) {
-    throw new UnimplementedError('KernelElementEnvironment.isSubtype');
+    // TODO(johnniwinther): Implement this.
+    return false;
   }
 
   @override
   FunctionType getFunctionType(KFunction function) {
     throw new UnimplementedError('KernelElementEnvironment.getFunctionType');
   }
 
   @override
-  FunctionType getLocalFunctionType(Local function) {
-    throw new UnimplementedError(
-        'KernelElementEnvironment.getLocalFunctionType');
+  FunctionType getLocalFunctionType(KLocalFunction function) {
+    return function.functionType;
   }
 
   @override
   DartType getUnaliasedType(DartType type) => type;
 
   @override
   ConstructorEntity lookupConstructor(ClassEntity cls, String name,
       {bool required: false}) {
     ConstructorEntity constructor = worldBuilder.lookupConstructor(cls, name);
     if (constructor == null && required) {
-      throw new SpannableAssertionFailure(CURRENT_ELEMENT_SPANNABLE,
-          "The constructor $name was not found in class '${cls.name}'.");
+      throw new SpannableAssertionFailure(
+          CURRENT_ELEMENT_SPANNABLE,
+          "The constructor '$name' was not found in class '${cls.name}' "
+          "in library ${cls.library.canonicalUri}.");
     }
     return constructor;
   }
 
   @override
   MemberEntity lookupClassMember(ClassEntity cls, String name,
       {bool setter: false, bool required: false}) {
     MemberEntity member =
         worldBuilder.lookupClassMember(cls, name, setter: setter);
     if (member == null && required) {
       throw new SpannableAssertionFailure(CURRENT_ELEMENT_SPANNABLE,
           "The member '$name' was not found in ${cls.name}.");
     }
     return member;
   }
 
   @override
   ClassEntity getSuperClass(ClassEntity cls) {
-    throw new UnimplementedError('KernelElementEnvironment.getSuperClass');
+    return worldBuilder._getSuperType(cls)?.element;
   }
 
   @override
   void forEachSupertype(ClassEntity cls, void f(InterfaceType supertype)) {
-    throw new UnimplementedError('KernelElementEnvironment.forEachSupertype');
+    worldBuilder._forEachSupertype(cls, f);
   }
 
   @override
   void forEachMixin(ClassEntity cls, void f(ClassEntity mixin)) {
     throw new UnimplementedError('KernelElementEnvironment.forEachMixin');
   }
 
   @override
   void forEachClassMember(
       ClassEntity cls, void f(ClassEntity declarer, MemberEntity member)) {
-    throw new UnimplementedError(
-        'KernelElementEnvironment.forEachInstanceMember');
+    // TODO(johnniwinther): Implement this.
   }
 
   @override
   MemberEntity lookupLibraryMember(LibraryEntity library, String name,
       {bool setter: false, bool required: false}) {
     MemberEntity member =
         worldBuilder.lookupLibraryMember(library, name, setter: setter);
     if (member == null && required) {
       throw new SpannableAssertionFailure(CURRENT_ELEMENT_SPANNABLE,
           "The member '${name}' was not found in library '${library.name}'.");
@@ skipping 58 matching lines @@
     topLevel = true;
     return type.accept(this);
   }
 
   /// Visit a inner type.
   DartType visitType(ir.DartType type) {
     topLevel = false;
     return type.accept(this);
   }
 
+  InterfaceType visitSupertype(ir.Supertype node) {
+    ClassEntity cls = elementAdapter.getClass(node.classNode);
+    return new InterfaceType(cls, visitTypes(node.typeArguments));
+  }
+
   List<DartType> visitTypes(List<ir.DartType> types) {
     topLevel = false;
     return new List.generate(
         types.length, (int index) => types[index].accept(this));
   }
 
   @override
   DartType visitTypeParameterType(ir.TypeParameterType node) {
     return new TypeVariableType(elementAdapter.getTypeVariable(node.parameter));
   }
@@ skipping 184 matching lines @@
   }
 
   InterfaceType getMixinTypeForClass(KClass cls) {
     KClassEnv env = builder._classEnvs[cls.classIndex];
     ir.Supertype mixedInType = env.cls.mixedInType;
     if (mixedInType == null) return null;
     return builder.createInterfaceType(
         mixedInType.classNode, mixedInType.typeArguments);
   }
 }