allow 'super' in async and finally blocks

lib/src/compiler/code_generator.dart

 // Copyright (c) 2015, 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 'dart:collection' show HashMap, HashSet;
 import 'dart:math' show min, max;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart' show Token, TokenType;
@@ skipping 100 matching lines @@
   FunctionBody _currentFunction;
 
   /// Helper class for emitting elements in the proper order to allow
   /// JS to load the module.
   ElementLoader _loader;
 
   BuildUnit _buildUnit;
 
   String _buildRoot;
 
+  bool _superAllowed = true;
+
+  List<JS.TemporaryId> _superHelperSymbols = <JS.TemporaryId>[];
+  List<JS.Method> _superHelpers = <JS.Method>[];
+
   /// Whether we are currently generating code for the body of a `JS()` call.
   bool _isInForeignJS = false;
 
   CodeGenerator(AnalysisContext c, this.options, this._extensionTypes)
       : context = c,
         types = c.typeProvider,
         _asyncStreamIterator =
             _getLibrary(c, 'dart:async').getType('StreamIterator').type,
         _jsArray = _getLibrary(c, 'dart:_interceptors').getType('JSArray'),
         dartCoreLibrary = _getLibrary(c, 'dart:core'),
@@ skipping 457 matching lines @@
     _registerPropertyOverrides(classElem, className, superclasses, allFields,
         virtualFields, virtualFieldSymbols, staticFieldOverrides);
 
     var classExpr = _emitClassExpression(classElem,
         _emitClassMethods(node, ctors, fields, superclasses, virtualFields),
         fields: allFields);
 
     var body = <JS.Statement>[];
     var extensions = _extensionsToImplement(classElem);
     _initExtensionSymbols(classElem, methods, fields, body);
+    _emitSuperHelperSymbols(_superHelperSymbols, body);
 
     // Emit the class, e.g. `core.Object = class Object { ... }`
     _defineClass(classElem, className, classExpr, body);
 
     // Emit things that come after the ES6 `class ... { ... }`.
     _setBaseClass(classElem, className, body);
     _defineNamedConstructors(ctors, body, className);
     _emitVirtualFieldSymbols(virtualFieldSymbols, body);
     _emitClassSignature(methods, classElem, ctors, extensions, className, body);
     _defineExtensionMembers(extensions, className, body);
     _emitClassMetadata(node.metadata, className, body);
 
     JS.Statement classDef = _statement(body);
     var typeFormals = classElem.typeParameters;
     if (typeFormals.isNotEmpty) {
       classDef = _defineClassTypeArguments(classElem, typeFormals, classDef);
     }
 
     body = <JS.Statement>[classDef];
     _emitStaticFields(staticFields, staticFieldOverrides, classElem, body);
     _registerExtensionType(classElem, body);
     return _statement(body);
   }
 
+  void _emitSuperHelperSymbols(
+      List<JS.TemporaryId> superHelperSymbols, List<JS.Statement> body) {
+    for (var id in superHelperSymbols) {
+      body.add(js.statement('const # = Symbol(#)', [id, js.string(id.name)]));
+    }
+    superHelperSymbols.clear();
+  }
+
   void _registerPropertyOverrides(
       ClassElement classElem,
       JS.Expression className,
       List<ClassElement> superclasses,
       List<FieldDeclaration> fields,
       Map<FieldElement, JS.TemporaryId> virtualFields,
       List<JS.Statement> virtualFieldSymbols,
       Set<FieldElement> staticFieldOverrides) {
     for (var field in fields) {
       for (VariableDeclaration field in field.fields.variables) {
@@ skipping 258 matching lines @@
     // helper on a parent class. This pattern is common in the core libraries
     // (e.g. IterableMixin<E> and IterableBase<E>).
     //
     // (We could do this same optimization for any interface with an `iterator`
     // method, but that's more expensive to check for, so it doesn't seem worth
     // it. The above case for an explicit `iterator` method will catch those.)
     if (!hasJsPeer && !hasIterator && _implementsIterable(type)) {
       jsMethods.add(_emitIterable(type));
     }
 
+    // Add all of the super helper methods
+    jsMethods.addAll(_superHelpers);
+    _superHelpers.clear();
+
     return jsMethods.where((m) => m != null).toList(growable: false);
   }
 
   /// This is called whenever a derived class needs to introduce a new field,
   /// shadowing a field or getter/setter pair on its parent.
   ///
   /// This is important because otherwise, trying to read or write the field
   /// would end up calling the getter or setter, and one of those might not even
   /// exist, resulting in a runtime error. Even if they did exist, that's the
   /// wrong behavior if a new field was declared.
@@ skipping 713 matching lines @@
       return new JS.Fun(params, js.statement('{ return this.#; }', [name]));
     } else if (node.isSetter) {
       return new JS.Fun(
           params, js.statement('{ this.# = #; }', [name, params.last]));
     } else {
       return new JS.Fun(
           params, js.statement('{ return this.#(#); }', [name, params]));
     }
   }
 
-  JS.Method _emitMethodDeclaration(DartType type, MethodDeclaration node) {
+  JS.Method _emitMethodDeclaration(InterfaceType type, MethodDeclaration node) {
     if (node.isAbstract) {
       return null;
     }
 
     JS.Fun fn;
     if (_externalOrNative(node)) {
       fn = _emitNativeFunctionBody(node);
       // TODO(vsm): Remove if / when we handle the static case above.
       if (fn == null) return null;
     } else {
@@ skipping 305 matching lines @@
     // `await` is generated as `yield`.
     // runtime/_generators.js has an example of what the code is generated as.
     var savedController = _asyncStarController;
     List jsParams = visitFormalParameterList(parameters);
     if (kind == 'asyncStar') {
       _asyncStarController = new JS.TemporaryId('stream');
       jsParams.insert(0, _asyncStarController);
     } else {
       _asyncStarController = null;
     }
+    var savedSuperAllowed = _superAllowed;
+    _superAllowed = false;
     // Visit the body with our async* controller set.
     var jsBody = _visit(body);
+    _superAllowed = savedSuperAllowed;
     _asyncStarController = savedController;
 
     DartType returnType = _getExpectedReturnType(element);
     JS.Expression gen = new JS.Fun(jsParams, jsBody,
         isGenerator: true, returnType: emitTypeRef(returnType));
     if (JS.This.foundIn(gen)) {
       gen = js.call('#.bind(this)', gen);
     }
 
     var T = _emitTypeName(returnType);
@@ skipping 25 matching lines @@
     return new JS.Block([
       declareFn,
       _emitFunctionTagged(name, func.element.type).toStatement()
     ]);
   }
 
   /// Emits a simple identifier, including handling an inferred generic
   /// function instantiation.
   @override
   JS.Expression visitSimpleIdentifier(SimpleIdentifier node) {
-    return _applyFunctionTypeArguments(
-        _emitSimpleIdentifier(node), node.staticElement, node.staticType);
+    var typeArgs = _getTypeArgs(node.staticElement, node.staticType);
+    var simpleId = _emitSimpleIdentifier(node);
+    if (typeArgs == null) {
+      return simpleId;
+    }
+    return js.call('dart.gbind(#, #)', [simpleId, typeArgs]);
   }
 
   /// Emits a simple identifier, handling implicit `this` as well as
   /// going through the qualified library name if necessary, but *not* handling
   /// inferred generic function instantiation.
   JS.Expression _emitSimpleIdentifier(SimpleIdentifier node) {
     var accessor = node.staticElement;
     if (accessor == null) {
       return js.commentExpression(
           'Unimplemented unknown name', new JS.Identifier(node.name));
@@ skipping 359 matching lines @@
     if (result != null) return result;
 
     var target = _getTarget(node);
     if (target == null || isLibraryPrefix(target)) {
       return _emitFunctionCall(node);
     }
 
     return _emitMethodCall(target, node);
   }
 
+  JS.Expression _emitMethodCall(Expression target, MethodInvocation node) {
+    List<JS.Expression> args = _visit(node.argumentList);
+    var typeArgs = _emitInvokeTypeArguments(node);
+
+    if (target is SuperExpression && !_superAllowed) {
+      return _emitSuperHelperCall(typeArgs, args, target, node);
+    }
+
+    return _emitMethodCallInternal(target, node, args, typeArgs);
+  }
+
+  JS.Expression _emitSuperHelperCall(List<JS.Expression> typeArgs,
+      List<JS.Expression> args, SuperExpression target, MethodInvocation node) {
+    var fakeTypeArgs =
+        typeArgs?.map((_) => new JS.TemporaryId('a'))?.toList(growable: false);
+    var fakeArgs =
+        args.map((_) => new JS.TemporaryId('a')).toList(growable: false);
+    var combinedFakeArgs = <JS.TemporaryId>[];
+    if (fakeTypeArgs != null) {
+      combinedFakeArgs.addAll(fakeTypeArgs);
+    }
+    combinedFakeArgs.addAll(fakeArgs);
+
+    var forwardedCall =
+        _emitMethodCallInternal(target, node, fakeArgs, fakeTypeArgs);
+    var superForwarder = _getSuperHelperFor(
+        node.methodName.name, forwardedCall, combinedFakeArgs);
+
+    var combinedRealArgs = <JS.Expression>[];
+    if (typeArgs != null) {
+      combinedRealArgs.addAll(typeArgs);
+    }
+    combinedRealArgs.addAll(args);
+
+    return js.call('this.#(#)', [superForwarder, combinedRealArgs]);
+  }
+
+  JS.Expression _getSuperHelperFor(String name, JS.Expression forwardedCall,
+      List<JS.Expression> helperArgs) {
+    var helperMethod =
+        new JS.Fun(helperArgs, new JS.Block([new JS.Return(forwardedCall)]));
+    var helperMethodName = new JS.TemporaryId('super\$$name');
+    _superHelperSymbols.add(helperMethodName);
+    _superHelpers.add(new JS.Method(helperMethodName, helperMethod));
+    return helperMethodName;
+  }
+
   /// Emits a (possibly generic) instance method call.
-  JS.Expression _emitMethodCall(Expression target, MethodInvocation node) {
+  JS.Expression _emitMethodCallInternal(
+      Expression target,
+      MethodInvocation node,
+      List<JS.Expression> args,
+      List<JS.Expression> typeArgs) {
     var type = getStaticType(target);
     var name = node.methodName.name;
     var element = node.methodName.staticElement;
     bool isStatic = element is ExecutableElement && element.isStatic;
     var memberName = _emitMemberName(name, type: type, isStatic: isStatic);
 
     JS.Expression jsTarget = _visit(target);
-    var typeArgs = _emitInvokeTypeArguments(node);
-    List<JS.Expression> args = _visit(node.argumentList);
     if (DynamicInvoke.get(target)) {
       if (typeArgs != null) {
         return js.call('dart.dgsend(#, #, #, #)',
             [jsTarget, new JS.ArrayInitializer(typeArgs), memberName, args]);
       } else {
         return js.call('dart.dsend(#, #, #)', [jsTarget, memberName, args]);
       }
     }
     if (_isObjectMemberCall(target, name)) {
       // Object methods require a helper for null checks & native types.
       assert(typeArgs == null); // Object methods don't take type args.
       return js.call('dart.#(#, #)', [memberName, jsTarget, args]);
     }
 
     jsTarget = new JS.PropertyAccess(jsTarget, memberName);
+
     if (typeArgs != null) jsTarget = new JS.Call(jsTarget, typeArgs);
 
     if (DynamicInvoke.get(node.methodName)) {
       // This is a dynamic call to a statically known target. For example:
       //     class Foo { Function bar; }
       //     new Foo().bar(); // dynamic call
       return js.call('dart.dcall(#, #)', [jsTarget, args]);
     }
 
     return new JS.Call(jsTarget, args);
@@ skipping 1114 matching lines @@
         (_extensionTypes.hasNativeSubtype(type) && target is! SuperExpression);
   }
 
   /// Shared code for [PrefixedIdentifier] and [PropertyAccess].
   JS.Expression _emitAccess(
       Expression target, SimpleIdentifier memberId, DartType resultType) {
     Element member = memberId.staticElement;
     if (member is PropertyAccessorElement) {
       member = (member as PropertyAccessorElement).variable;
     }
+    String memberName = memberId.name;
+    var typeArgs = _getTypeArgs(member, resultType);
+
+    if (target is SuperExpression && !_superAllowed) {
+      return _emitSuperHelperAccess(target, member, memberName, typeArgs);
+    }
+    return _emitAccessInternal(target, member, memberName, typeArgs);
+  }
+
+  JS.Expression _emitSuperHelperAccess(SuperExpression target, Element member,
+      String memberName, List<JS.Expression> typeArgs) {
+    var fakeTypeArgs =
+        typeArgs?.map((_) => new JS.TemporaryId('a'))?.toList(growable: false);
+
+    var forwardedAccess =
+        _emitAccessInternal(target, member, memberName, fakeTypeArgs);
+    var superForwarder = _getSuperHelperFor(
+        memberName, forwardedAccess, fakeTypeArgs ?? const []);
+
+    return js.call('this.#(#)', [superForwarder, typeArgs ?? const []]);
+  }
+
+  List<JS.Expression> _getTypeArgs(Element member, DartType instantiated) {
+    DartType type;
+    if (member is ExecutableElement) {
+      type = member.type;
+    } else if (member is VariableElement) {
+      type = member.type;
+    }
+
+    // TODO(jmesserly): handle explicitly passed type args.
+    if (type == null) return null;
+    return _emitFunctionTypeArguments(type, instantiated);
+  }
+
+  JS.Expression _emitAccessInternal(Expression target, Element member,
+      String memberName, List<JS.Expression> typeArgs) {
     bool isStatic = member is ClassMemberElement && member.isStatic;
-    var name = _emitMemberName(memberId.name,
+    var name = _emitMemberName(memberName,
         type: getStaticType(target), isStatic: isStatic);
     if (DynamicInvoke.get(target)) {
       return js.call('dart.dload(#, #)', [_visit(target), name]);
     }
 
     var jsTarget = _visit(target);
     bool isSuper = jsTarget is JS.Super;
 
     if (isSuper && member is FieldElement && !member.isSynthetic) {
       // If super.x is actually a field, then x is an instance property since
       // subclasses cannot override x.
       jsTarget = new JS.This();
     }
 
     JS.Expression result;
     if (member != null && member is MethodElement && !isStatic) {
       // Tear-off methods: explicitly bind it.
       if (isSuper) {
         result = js.call('dart.bind(this, #, #.#)', [name, jsTarget, name]);
-      } else if (_isObjectMemberCall(target, memberId.name)) {
+      } else if (_isObjectMemberCall(target, memberName)) {
         result = js.call('dart.bind(#, #, dart.#)', [jsTarget, name, name]);
       } else {
         result = js.call('dart.bind(#, #)', [jsTarget, name]);
       }
-    } else if (_isObjectMemberCall(target, memberId.name)) {
+    } else if (_isObjectMemberCall(target, memberName)) {
       result = js.call('dart.#(#)', [name, jsTarget]);
     } else {
       result = js.call('#.#', [jsTarget, name]);
     }
-    return _applyFunctionTypeArguments(result, member, resultType);
-  }
-
-  /// If this is an inferred instantiation of a generic function/method, this
-  /// will add the inferred type arguments.
-  JS.Expression _applyFunctionTypeArguments(
-      JS.Expression result, Element member, DartType instantiated) {
-    DartType type;
-    if (member is ExecutableElement) {
-      type = member.type;
-    } else if (member is VariableElement) {
-      type = member.type;
+    if (typeArgs == null) {
+      return result;
     }
-
-    // TODO(jmesserly): handle explicitly passed type args.
-    if (type == null) return result;
-    var typeArgs = _emitFunctionTypeArguments(type, instantiated);
-    if (typeArgs == null) return result;
     return js.call('dart.gbind(#, #)', [result, typeArgs]);
   }
 
   /// Emits a generic send, like an operator method.
   ///
   /// **Please note** this function does not support method invocation syntax
   /// `obj.name(args)` because that could be a getter followed by a call.
   /// See [visitMethodInvocation].
   JS.Expression _emitSend(
       Expression target, String name, List<Expression> args) {
@@ skipping 177 matching lines @@
   }
 
   @override
   visitContinueStatement(ContinueStatement node) {
     var label = node.label;
     return new JS.Continue(label?.name);
   }
 
   @override
   visitTryStatement(TryStatement node) {
-    return new JS.Try(_visit(node.body), _visitCatch(node.catchClauses),
-        _visit(node.finallyBlock));
+    var savedSuperAllowed = _superAllowed;
+    _superAllowed = false;
+    var finallyBlock = _visit(node.finallyBlock);
+    _superAllowed = savedSuperAllowed;
+    return new JS.Try(
+        _visit(node.body), _visitCatch(node.catchClauses), finallyBlock);
   }
 
   _visitCatch(NodeList<CatchClause> clauses) {
     if (clauses == null || clauses.isEmpty) return null;
 
     // TODO(jmesserly): need a better way to get a temporary variable.
     // This could incorrectly shadow a user's name.
     var savedCatch = _catchParameter;
 
     if (clauses.length == 1 && clauses.single.exceptionParameter != null) {
@@ skipping 487 matching lines @@
 }
 
 bool isLibraryPrefix(Expression node) =>
     node is SimpleIdentifier && node.staticElement is PrefixElement;
 
 LibraryElement _getLibrary(AnalysisContext c, String uri) =>
     c.computeLibraryElement(c.sourceFactory.forUri(uri));
 
 bool _isDartRuntime(LibraryElement l) =>
     l.isInSdk && l.source.uri.toString() == 'dart:_runtime';