Added ThisVariable in scoping and the captured scope of initialized fields.

pkg/compiler/lib/src/js_model/closure.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 '../closure.dart';
 import '../common.dart';
 import '../common/tasks.dart';
 import '../constants/expressions.dart';
 import '../constants/values.dart';
 import '../elements/entities.dart';
 import '../elements/names.dart' show Name;
 import '../elements/types.dart';
 import '../kernel/element_map.dart';
 import '../kernel/env.dart';
 import '../world.dart';
 import 'elements.dart';
 import 'closure_visitors.dart';
 import 'locals.dart';
 import 'js_strategy.dart' show JsClosedWorld;
 
 class KernelClosureAnalysis {
   /// Inspect members and mark if those members capture any state that needs to
   /// be marked as free variables.
-  static ClosureModel computeClosureModel(MemberEntity entity, ir.Member node) {
+  static ScopeModel computeScopeModel(MemberEntity entity, ir.Member node) {
     if (entity.isAbstract) return null;
     if (entity.isField && !entity.isInstanceMember) {
       ir.Field field = node;
       // Skip top-level/static fields without an initializer.
       if (field.initializer == null) return null;
     }
 
-    ClosureModel model = new ClosureModel();
+    ScopeModel model = new ScopeModel();
     CapturedScopeBuilder translator = new CapturedScopeBuilder(model,
         hasThisLocal: entity.isInstanceMember || entity.isConstructor);
     if (entity.isField) {
       if (node is ir.Field && node.initializer != null) {
         translator.translateLazyInitializer(node);
+      } else {
+        assert(entity.isInstanceMember);
+        model.scopeInfo = new KernelScopeInfo(true);
       }
     } else {
       assert(node is ir.Procedure || node is ir.Constructor);
       translator.translateConstructorOrProcedure(node);
     }
     return model;
   }
 }
 
 /// Closure conversion code using our new Entity model. Closure conversion is
 /// necessary because the semantics of closures are slightly different in Dart
 /// than JavaScript. Closure conversion is separated out into two phases:
 /// generation of a new (temporary) representation to store where variables need
 /// to be hoisted/captured up at another level to re-write the closure, and then
 /// the code generation phase where we generate elements and/or instructions to
 /// represent this new code path.
 ///
 /// For a general explanation of how closure conversion works at a high level,
 /// check out:
 /// http://siek.blogspot.com/2012/07/essence-of-closure-conversion.html or
 /// http://matt.might.net/articles/closure-conversion/.
 // TODO(efortuna): Change inheritance hierarchy so that the
 // ClosureConversionTask doesn't inherit from ClosureTask because it's just a
 // glorified timer.
 class KernelClosureConversionTask extends ClosureConversionTask<ir.Node> {
   final KernelToElementMapForBuilding _elementMap;
   final GlobalLocalsMap _globalLocalsMap;
-  final Map<MemberEntity, ClosureModel> _closureModels;
+  final Map<MemberEntity, ScopeModel> _closureModels;
 
   /// Map of the scoping information that corresponds to a particular entity.
   Map<Entity, ScopeInfo> _scopeMap = <Entity, ScopeInfo>{};
   Map<ir.Node, CapturedScope> _capturedScopesMap = <ir.Node, CapturedScope>{};
 
   Map<Entity, ClosureRepresentationInfo> _closureRepresentationMap =
       <Entity, ClosureRepresentationInfo>{};
 
   KernelClosureConversionTask(Measurer measurer, this._elementMap,
       this._globalLocalsMap, this._closureModels)
       : super(measurer);
 
   /// The combined steps of generating our intermediate representation of
   /// closures that need to be rewritten and generating the element model.
   /// Ultimately these two steps will be split apart with the second step
   /// happening later in compilation just before codegen. These steps are
   /// combined here currently to provide a consistent interface to the rest of
   /// the compiler until we are ready to separate these phases.
   @override
   void convertClosures(Iterable<MemberEntity> processedEntities,
       ClosedWorldRefiner closedWorldRefiner) {
     _createClosureEntities(_closureModels, closedWorldRefiner);
   }
 
-  void _createClosureEntities(Map<MemberEntity, ClosureModel> closureModels,
+  void _createClosureEntities(Map<MemberEntity, ScopeModel> closureModels,
       JsClosedWorld closedWorldRefiner) {
-    closureModels.forEach((MemberEntity member, ClosureModel model) {
+    closureModels.forEach((MemberEntity member, ScopeModel model) {
       KernelToLocalsMap localsMap = _globalLocalsMap.getLocalsMap(member);
       if (model.scopeInfo != null) {
         _scopeMap[member] = new JsScopeInfo.from(model.scopeInfo, localsMap);
       }
 
       model.capturedScopesMap
           .forEach((ir.Node node, KernelCapturedScope scope) {
         if (scope is KernelCapturedLoopScope) {
           _capturedScopesMap[node] =
               new JsCapturedLoopScope.from(scope, localsMap);
@@ skipping 65 matching lines @@
     }
   }
 
   @override
   // TODO(efortuna): Eventually capturedScopesMap[node] should always
   // be non-null, and we should just test that with an assert.
   CapturedLoopScope getCapturedLoopScope(ir.Node loopNode) =>
       _capturedScopesMap[loopNode] ?? const CapturedLoopScope();
 
   @override
-  // TODO(efortuna): Eventually closureRepresentationMap[node] should always be
-  // non-null, and we should just test that with an assert.
   ClosureRepresentationInfo getClosureRepresentationInfo(Entity entity) {
-    return _closureRepresentationMap[entity] ??
-        const ClosureRepresentationInfo();
+    var closure = _closureRepresentationMap[entity];
+    assert(closure != null,
+        "Corresponding closure class not found for $entity. Closures found for ${_closureRepresentationMap.keys}");
+    return closure;
   }
 }
 
 class KernelScopeInfo {
   final Set<ir.VariableDeclaration> localsUsedInTryOrSync;
   final bool hasThisLocal;
   final Set<ir.VariableDeclaration> boxedVariables;
   // If boxedVariables is empty, this will be null, because no variables will
   // need to be boxed.
   final NodeBox capturedVariablesAccessor;
@@ skipping 126 matching lines @@
   bool get hasBoxedLoopVariables => boxedLoopVariables.isNotEmpty;
 }
 
 // TODO(johnniwinther): Add unittest for the computed [ClosureClass].
 class KernelClosureClass extends JsScopeInfo
     implements ClosureRepresentationInfo, JClass {
   final String name;
   final JLibrary library;
   JFunction callMethod;
   final Local closureEntity;
+  final Local thisLocal;
 
   /// Index into the classData, classList and classEnvironment lists where this
   /// entity is stored in [JsToFrontendMapImpl].
   final int classIndex;
 
   final Map<Local, JField> localToFieldMap = new Map<Local, JField>();
 
   KernelClosureClass.fromScopeInfo(
       ir.FunctionNode closureSourceNode,
       this.name,
       this.classIndex,
       this.library,
       KernelScopeInfo info,
       KernelToLocalsMap localsMap)
       : closureEntity = closureSourceNode.parent is ir.Member
             ? null
             : localsMap.getLocalFunction(closureSourceNode.parent),
+        thisLocal =
+            info.hasThisLocal ? new ThisLocal(localsMap.currentMember) : null,
         super.from(info, localsMap);
 
   ClassEntity get closureClassEntity => this;
 
   List<Local> get createdFieldEntities => localToFieldMap.keys.toList();
 
-  // TODO(efortuna): Implement.
-  FieldEntity get thisFieldEntity => null;
+  FieldEntity get thisFieldEntity => localToFieldMap[thisLocal];
 
   void forEachCapturedVariable(f(Local from, JField to)) {
     localToFieldMap.forEach(f);
   }
 
   @override
   void forEachBoxedVariable(f(Local local, JField field)) {
     for (Local l in localToFieldMap.keys) {
       if (localToFieldMap[l] is JBoxedField) f(l, localToFieldMap[l]);
     }
@@ skipping 131 matching lines @@
   final SourceSpan location;
   final MemberKind kind;
   final ir.Node node;
 
   ClosureMemberDefinition(this.member, this.location, this.kind, this.node);
 
   String toString() =>
       'ClosureMemberDefinition(kind:$kind,member:$member,location:$location)';
 }
 
-/// Collection of closure data collected for a single member.
-class ClosureModel {
-  /// Collection [ScopeInfo] data for the member, if any.
-  // TODO(johnniwinther): [scopeInfo] seem to be missing only for fields
-  // without initializers; we shouldn't even create a [ClosureModel] in these
-  // cases.
+/// Collection of scope data collected for a single member.
+class ScopeModel {
+  /// Collection [ScopeInfo] data for the member.
   KernelScopeInfo scopeInfo;
 
   /// Collected [CapturedScope] data for nodes.
   Map<ir.Node, KernelCapturedScope> capturedScopesMap =
       <ir.Node, KernelCapturedScope>{};
 
   /// Collected [ScopeInfo] data for nodes.
   Map<ir.FunctionNode, KernelScopeInfo> closuresToGenerate =
       <ir.FunctionNode, KernelScopeInfo>{};
 }