Make instance methods whose names collide with intercepted methods have the interceptor calling con…

sdk/lib/_internal/compiler/implementation/js_backend/emitter.dart

 // Copyright (c) 2012, 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.
 
 part of js_backend;
 
 /**
  * A function element that represents a closure call. The signature is copied
  * from the given element.
  */
@@ skipping 635 matching lines @@
       // hit the method directly.
       return;
     }
     ConstantHandler handler = compiler.constantHandler;
     List<SourceString> names = selector.getOrderedNamedArguments();
 
     String invocationName = namer.invocationName(selector);
     if (alreadyGenerated.contains(invocationName)) return;
     alreadyGenerated.add(invocationName);
 
-    bool isInterceptorClass =
-        backend.isInterceptorClass(member.getEnclosingClass());
+    bool isInterceptedMethod = backend.isInterceptedMethod(member);
 
-    // If the method is in an interceptor class, we need to also pass
+    // If the method is intercepted, we need to also pass
     // the actual receiver.
-    int extraArgumentCount = isInterceptorClass ? 1 : 0;
+    int extraArgumentCount = isInterceptedMethod ? 1 : 0;
     // Use '$receiver' to avoid clashes with other parameter names. Using
     // '$receiver' works because [:namer.safeName:] used for getting parameter
     // names never returns a name beginning with a single '$'.
     String receiverArgumentName = r'$receiver';
 
     // The parameters that this stub takes.
     List<jsAst.Parameter> parametersBuffer =
         new List<jsAst.Parameter>(selector.argumentCount + extraArgumentCount);
     // The arguments that will be passed to the real method.
     List<jsAst.Expression> argumentsBuffer =
         new List<jsAst.Expression>(
             parameters.parameterCount + extraArgumentCount);
 
     int count = 0;
-    if (isInterceptorClass) {
+    if (isInterceptedMethod) {
       count++;
       parametersBuffer[0] = new jsAst.Parameter(receiverArgumentName);
       argumentsBuffer[0] = js[receiverArgumentName];
     }
 
     int indexOfLastOptionalArgumentInParameters = positionalArgumentCount - 1;
     TreeElements elements =
         compiler.enqueuer.resolution.getCachedElements(member);
 
     parameters.orderedForEachParameter((Element element) {
@@ skipping 219 matching lines @@
   }
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [classElement] must be a declaration element.
    */
   void emitInstanceMembers(ClassElement classElement,
                            ClassBuilder builder) {
     assert(invariant(classElement, classElement.isDeclaration));
-    if (classElement == backend.objectInterceptorClass) {
-      emitInterceptorMethods(builder);
-      // The ObjectInterceptor does not have any instance methods.
-      return;
-    }
 
     void visitMember(ClassElement enclosing, Element member) {
       assert(invariant(classElement, member.isDeclaration));
       if (member.isInstanceMember()) {
         addInstanceMember(member, builder);
       }
     }
 
     // TODO(kasperl): We should make sure to only emit one version of
     // overridden methods. Right now, we rely on the ordering so the
@@ skipping 57 matching lines @@
         && compiler.enabledNoSuchMethod) {
       // Emit the noSuchMethod handlers on the Object prototype now,
       // so that the code in the dynamicFunction helper can find
       // them. Note that this helper is invoked before analyzing the
       // full JS script.
       if (!nativeEmitter.handleNoSuchMethod) {
         emitNoSuchMethodHandlers(builder.addProperty);
       }
     }
 
-    if (backend.isInterceptorClass(classElement)) {
-      // The operator== method in [:Object:] does not take the same
-      // number of arguments as an intercepted method, therefore we
-      // explicitely add one to all interceptor classes. Note that we
-      // would not have do do that if all intercepted methods had
-      // a calling convention where the receiver is the first
-      // parameter.
+    if (backend.isInterceptorClass(classElement)
+        && classElement != compiler.objectClass) {
+      // We optimize the operator== on interceptor classes to
+      // just do a JavaScript double or triple equals.
       String name = backend.namer.publicInstanceMethodNameByArity(
           const SourceString('=='), 1);
       Function kind = (classElement == backend.jsNullClass)
           ? js.equals
           : js.strictEquals;
       builder.addProperty(name, js.fun(['receiver', 'a'],
           js.block(js.return_(kind(js['receiver'], js['a'])))));
     }
   }
 
@@ skipping 107 matching lines @@
       if ((isInstantiated && !enclosingClass.isNative())
           || needsGetter
           || needsSetter) {
         String accessorName = isShadowed
             ? namer.shadowedFieldName(member)
             : namer.getName(member);
         String fieldName = member.hasFixedBackendName()
             ? member.fixedBackendName()
             : (isMixinNativeField ? member.name.slowToString() : accessorName);
         bool needsCheckedSetter = false;
-        if (needsSetter && compiler.enableTypeAssertions
-            && canGenerateCheckedSetter(member)) {
-          needsCheckedSetter = true;
-          needsSetter = false;
+        if (needsSetter) {
+          if (compiler.enableTypeAssertions
+              && canGenerateCheckedSetter(member)) {
+            needsCheckedSetter = true;
+            needsSetter = false;
+          } else if (backend.isInterceptedMethod(member)) {
+            // The [addField] will take care of generating the setter.
+            needsSetter = false;
+          }
         }
         // Getters and setters with suffixes will be generated dynamically.
         addField(member,
                  fieldName,
                  accessorName,
                  needsGetter,
                  needsSetter,
                  needsCheckedSetter);
       }
     }
@@ skipping 17 matching lines @@
     // allowed on fields that are in [classElement] we don't need to visit
     // superclasses for non-instantiated classes.
     classElement.implementation.forEachInstanceField(
         visitField,
         includeBackendMembers: true,
         includeSuperMembers: isInstantiated && !classElement.isNative());
   }
 
   void generateGetter(Element member, String fieldName, String accessorName,
                       ClassBuilder builder) {
+    assert(!backend.isInterceptorClass(member));
     String getterName = namer.getterNameFromAccessorName(accessorName);
     builder.addProperty(getterName,
         js.fun([], js.return_(js['this'][fieldName])));
   }
 
   void generateSetter(Element member, String fieldName, String accessorName,
                       ClassBuilder builder) {
+    assert(!backend.isInterceptorClass(member));
     String setterName = namer.setterNameFromAccessorName(accessorName);
+    List<String> args = backend.isInterceptedMethod(member)
+        ? ['receiver', 'v']
+        : ['v'];
     builder.addProperty(setterName,
-        js.fun(['v'], js['this'][fieldName].assign('v')));
+        js.fun(args, js['this'][fieldName].assign('v')));
   }
 
   bool canGenerateCheckedSetter(Element member) {
     DartType type = member.computeType(compiler);
     if (type.element.isTypeVariable()
         || type.element == compiler.dynamicClass
         || type.element == compiler.objectClass) {
       // TODO(ngeoffray): Support type checks on type parameters.
       return false;
     }
@@ skipping 10 matching lines @@
     if (type.element.isErroneous()) return;
     FunctionElement helperElement
         = backend.getCheckedModeHelper(type, typeCast: false);
     String helperName = namer.isolateAccess(helperElement);
     List<jsAst.Expression> arguments = <jsAst.Expression>[js['v']];
     if (helperElement.computeSignature(compiler).parameterCount != 1) {
       arguments.add(js.string(namer.operatorIs(type.element)));
     }
 
     String setterName = namer.setterNameFromAccessorName(accessorName);
+    List<String> args = backend.isInterceptedMethod(member)
+        ? ['receiver', 'v']
+        : ['v'];
     builder.addProperty(setterName,
-        js.fun(['v'], js['this'][fieldName].assign(js[helperName](arguments))));
+        js.fun(args, js['this'][fieldName].assign(js[helperName](arguments))));
   }
 
   void emitClassConstructor(ClassElement classElement, ClassBuilder builder) {
     /* Do nothing. */
   }
 
   void emitSuper(String superName, ClassBuilder builder) {
     /* Do nothing. */
   }
 
@@ skipping 71 matching lines @@
           assert(!needsSetter);
           generateCheckedSetter(member, name, accessorName, builder);
         }
         if (!getterAndSetterCanBeImplementedByFieldSpec) {
           if (needsGetter) {
             generateGetter(member, name, accessorName, builder);
           }
           if (needsSetter) {
             generateSetter(member, name, accessorName, builder);
           }
+        } else if (backend.isInterceptedMethod(member)
+                   && instanceFieldNeedsSetter(member)) {
+          generateSetter(member, name, accessorName, builder);
         }
       });
     });
   }
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [classElement] must be a declaration element.
    */
@@ skipping 39 matching lines @@
     return arity;
   }
 
   int _compareSelectorNames(Selector selector1, Selector selector2) {
     String name1 = selector1.name.toString();
     String name2 = selector2.name.toString();
     if (name1 != name2) return Comparable.compare(name1, name2);
     return _selectorRank(selector1) - _selectorRank(selector2);
   }
 
-  void emitInterceptorMethods(ClassBuilder builder) {
-    // Emit forwarders for the ObjectInterceptor class. We need to
-    // emit all possible sends on intercepted methods. Because of
-    // typed selectors we have to avoid generating the same forwarder
-    // multiple times.
-    Set<String> alreadyGenerated = new Set<String>();
-    for (Selector selector in
-         backend.usedInterceptors.toList()..sort(_compareSelectorNames)) {
-      String name = backend.namer.invocationName(selector);
-      if (alreadyGenerated.contains(name)) continue;
-      alreadyGenerated.add(name);
-
-      List<jsAst.Parameter> parameters = <jsAst.Parameter>[];
-      List<jsAst.Expression> arguments = <jsAst.Expression>[];
-      parameters.add(new jsAst.Parameter('receiver'));
-
-      if (selector.isSetter()) {
-        parameters.add(new jsAst.Parameter('value'));
-        arguments.add(js['value']);
-      } else {
-        for (int i = 0; i < selector.argumentCount; i++) {
-          String argName = 'a$i';
-          parameters.add(new jsAst.Parameter(argName));
-          arguments.add(js[argName]);
-        }
-      }
-      jsAst.Fun function =
-          js.fun(parameters, js.return_(js['receiver'][name](arguments)));
-      builder.addProperty(name, function);
-    }
-  }
-
   Iterable<Element> getTypedefChecksOn(DartType type) {
     bool isSubtype(TypedefElement typedef) {
       FunctionType typedefType =
           typedef.computeType(compiler).unalias(compiler);
       return compiler.types.isSubtype(type, typedefType);
     }
     return checkedTypedefs.where(isSubtype).toList()
         ..sort(Elements.compareByPosition);
   }
 
@@ skipping 146 matching lines @@
     for (Constant constant in constants) {
       if (constant is ConstructedConstant) {
         Element element = constant.computeType(compiler).element;
         if (backend.isInterceptorClass(element)) {
           needed.add(element);
         }
       }
     }
 
     // Add unneeded interceptors to the [unneededClasses] set.
-    for (ClassElement interceptor in backend.interceptedClasses.keys) {
-      if (!needed.contains(interceptor)) {
+    for (ClassElement interceptor in backend.interceptedClasses) {
+      if (!needed.contains(interceptor)
+          && interceptor != compiler.objectClass) {
         unneededClasses.add(interceptor);
       }
     }
 
     return (ClassElement cls) => !unneededClasses.contains(cls);
   }
 
   void emitClosureClassIfNeeded(CodeBuffer buffer) {
     // The closure class could have become necessary because of the generation
     // of stubs.
@@ skipping 129 matching lines @@
     // if they share methods with the same signature. Currently we do this only
     // if there are no optional parameters. Closures with optional parameters
     // are more difficult to canonicalize because they would need to have the
     // same default values.
 
     bool hasOptionalParameters = member.optionalParameterCount(compiler) != 0;
     int parameterCount = member.parameterCount(compiler);
 
     Map<int, String> cache;
     String extraArg = null;
-    // Methods on interceptor classes take an extra parameter, which is the
-    // actual receiver of the call.
-    bool inInterceptor = backend.isInterceptorClass(member.getEnclosingClass());
+    // Intercepted methods take an extra parameter, which is the
+    // receiver of the call.
+    bool inInterceptor = backend.isInterceptedMethod(member);
     if (inInterceptor) {
       cache = interceptorClosureCache;
       extraArg = 'receiver';
     } else {
       cache = boundClosureCache;
     }
     List<String> fieldNames = compiler.enableMinification
         ? inInterceptor ? const ['a', 'b', 'c']
                         : const ['a', 'b']
         : inInterceptor ? const ['self', 'target', 'receiver']
@@ skipping 100 matching lines @@
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [member] must be a declaration element.
    */
   void emitCallStubForGetter(Element member,
                              Set<Selector> selectors,
                              DefineStubFunction defineStub) {
     assert(invariant(member, member.isDeclaration));
     LibraryElement memberLibrary = member.getLibrary();
-    // If the class is an interceptor class, the stub gets the
+    // If the method is intercepted, the stub gets the
     // receiver explicitely and we need to pass it to the getter call.
-    bool isInterceptorClass =
-        backend.isInterceptorClass(member.getEnclosingClass());
+    bool isInterceptedMethod = backend.isInterceptedMethod(member);
 
     const String receiverArgumentName = r'$receiver';
 
     jsAst.Expression buildGetter() {
       if (member.isGetter()) {
         String getterName = namer.getterName(member);
         return js['this'][getterName](
-            isInterceptorClass
+            isInterceptedMethod
                 ? <jsAst.Expression>[js[receiverArgumentName]]
                 : <jsAst.Expression>[]);
       } else {
         String fieldName = member.hasFixedBackendName()
             ? member.fixedBackendName()
             : namer.instanceFieldName(member);
         return js['this'][fieldName];
       }
     }
 
     // Two selectors may match but differ only in type.  To avoid generating
     // identical stubs for each we track untyped selectors which already have
     // stubs.
     Set<Selector> generatedSelectors = new Set<Selector>();
 
     for (Selector selector in selectors) {
       if (selector.applies(member, compiler)) {
         selector = selector.asUntyped;
         if (generatedSelectors.contains(selector)) continue;
         generatedSelectors.add(selector);
 
         String invocationName = namer.invocationName(selector);
         Selector callSelector = new Selector.callClosureFrom(selector);
         String closureCallName = namer.invocationName(callSelector);
 
         List<jsAst.Parameter> parameters = <jsAst.Parameter>[];
         List<jsAst.Expression> arguments = <jsAst.Expression>[];
-        if (isInterceptorClass) {
+        if (isInterceptedMethod) {
           parameters.add(new jsAst.Parameter(receiverArgumentName));
         }
 
         for (int i = 0; i < selector.argumentCount; i++) {
           String name = 'arg$i';
           parameters.add(new jsAst.Parameter(name));
           arguments.add(js[name]);
         }
 
         jsAst.Fun function = js.fun(
             parameters,
             js.return_(buildGetter()[closureCallName](arguments)));
 
         defineStub(invocationName, function);
       }
     }
   }
 
   void emitStaticNonFinalFieldInitializations(CodeBuffer buffer) {
     ConstantHandler handler = compiler.constantHandler;
     Iterable<VariableElement> staticNonFinalFields =
         handler.getStaticNonFinalFieldsForEmission();
     for (Element element in Elements.sortedByPosition(staticNonFinalFields)) {
+      // [:interceptedNames:] is handled in [emitInterceptedNames].
+      if (element == backend.interceptedNames) continue;
       compiler.withCurrentElement(element, () {
         Constant initialValue = handler.getInitialValueFor(element);
         jsAst.Expression init =
           js[isolateProperties][namer.getName(element)].assign(
               constantEmitter.referenceInInitializationContext(initialValue));
         buffer.add(jsAst.prettyPrint(init, compiler));
         buffer.add('$N');
       });
     }
   }
@@ skipping 118 matching lines @@
 
       List<jsAst.Expression> argNames =
           selector.getOrderedNamedArguments().map((SourceString name) =>
               js.string(name.slowToString())).toList();
 
       String internalName = namer.invocationMirrorInternalName(selector);
 
       String createInvocationMirror = namer.getName(
           compiler.createInvocationMirrorElement);
 
+      assert(backend.isInterceptedName(Compiler.NO_SUCH_METHOD));
       jsAst.Expression expression = js['this.$noSuchMethodName'](
-          js[namer.CURRENT_ISOLATE][createInvocationMirror]([
-              js.string(methodName),
-              js.string(internalName),
-              type,
-              new jsAst.ArrayInitializer.from(
-                  parameters.map((param) => js[param.name]).toList()),
-              new jsAst.ArrayInitializer.from(argNames)]));
+          [js['this'],
+           js[namer.CURRENT_ISOLATE][createInvocationMirror]([
+               js.string(methodName),
+               js.string(internalName),
+               type,
+               new jsAst.ArrayInitializer.from(
+                   parameters.map((param) => js[param.name]).toList()),
+               new jsAst.ArrayInitializer.from(argNames)])]);
+      parameters = backend.isInterceptedName(selector.name)
+          ? ([new jsAst.Parameter('\$receiver')]..addAll(parameters))
+          : parameters;
       return js.fun(parameters, js.return_(expression));
     }
 
     void addNoSuchMethodHandlers(SourceString ignore, Set<Selector> selectors) {
       // Cache the object class and type.
       ClassElement objectClass = compiler.objectClass;
       DartType objectType = objectClass.computeType(compiler);
 
       for (Selector selector in selectors) {
         // Introduce a helper function that determines if the given
@@ skipping 120 matching lines @@
     dartMainRunner(function() { ${mainCall}; });
   } else {
     ${mainCall};
   }
 }
 """);
     addComment('END invoke [main].', buffer);
   }
 
   void emitGetInterceptorMethod(CodeBuffer buffer,
-                                String objectName,
                                 String key,
                                 Collection<ClassElement> classes) {
     jsAst.Statement buildReturnInterceptor(ClassElement cls) {
       return js.return_(js[namer.isolateAccess(cls)]['prototype']);
     }
 
     jsAst.VariableUse receiver = js['receiver'];
     /**
      * Build a JavaScrit AST node for doing a type check on
      * [cls]. [cls] must be an interceptor class.
@@ skipping 31 matching lines @@
     bool hasString = false;
     for (ClassElement cls in classes) {
       if (cls == backend.jsArrayClass) hasArray = true;
       else if (cls == backend.jsBoolClass) hasBool = true;
       else if (cls == backend.jsDoubleClass) hasDouble = true;
       else if (cls == backend.jsFunctionClass) hasFunction = true;
       else if (cls == backend.jsIntClass) hasInt = true;
       else if (cls == backend.jsNullClass) hasNull = true;
       else if (cls == backend.jsNumberClass) hasNumber = true;
       else if (cls == backend.jsStringClass) hasString = true;
-      else throw 'Internal error: $cls';
+      else {
+        assert(cls == compiler.objectClass);
+      }
     }
     if (hasDouble) {
-      assert(!hasNumber);
       hasNumber = true;
     }
     if (hasInt) hasNumber = true;
 
     jsAst.Block block = new jsAst.Block.empty();
 
     if (hasNumber) {
       jsAst.Statement whenNumber;
 
       /// Note: there are two number classes in play: Dart's [num],
@@ skipping 32 matching lines @@
       block.statements.add(buildInterceptorCheck(backend.jsFunctionClass));
     }
     if (hasBool) {
       block.statements.add(buildInterceptorCheck(backend.jsBoolClass));
     }
     // TODO(ahe): It might be faster to check for Array before
     // function and bool.
     if (hasArray) {
       block.statements.add(buildInterceptorCheck(backend.jsArrayClass));
     }
-    block.statements.add(js.return_(js[objectName]['prototype']));
+    block.statements.add(js.return_(receiver));
 
     buffer.add(jsAst.prettyPrint(
         js[isolateProperties][key].assign(js.fun(['receiver'], block)),
         compiler));
     buffer.add(N);
   }
 
   /**
    * Emit all versions of the [:getInterceptor:] method.
    */
   void emitGetInterceptorMethods(CodeBuffer buffer) {
-    // If no class needs to be intercepted, just return.
-    if (backend.objectInterceptorClass == null) return;
-    String objectName = namer.isolateAccess(backend.objectInterceptorClass);
     var specializedGetInterceptors = backend.specializedGetInterceptors;
     for (String name in specializedGetInterceptors.keys.toList()..sort()) {
       Collection<ClassElement> classes = specializedGetInterceptors[name];
-      emitGetInterceptorMethod(buffer, objectName, name, classes);
+      emitGetInterceptorMethod(buffer, name, classes);
     }
   }
 
   /**
    * Compute all the classes that must be emitted.
    */
   void computeNeededClasses() {
     instantiatedClasses =
         compiler.codegenWorld.instantiatedClasses.where(computeClassFilter())
             .toSet();
@@ skipping 205 matching lines @@
     }
     return null;
   }
 
   void emitOneShotInterceptors(CodeBuffer buffer) {
     List<String> names = backend.oneShotInterceptors.keys.toList();
     names.sort();
     for (String name in names) {
       Selector selector = backend.oneShotInterceptors[name];
       Set<ClassElement> classes =
-          backend.getInterceptedClassesOn(selector);
+          backend.getInterceptedClassesOn(selector.name);
       String getInterceptorName =
           namer.getInterceptorName(backend.getInterceptorMethod, classes);
 
       List<jsAst.Parameter> parameters = <jsAst.Parameter>[];
       List<jsAst.Expression> arguments = <jsAst.Expression>[];
       parameters.add(new jsAst.Parameter('receiver'));
       arguments.add(js['receiver']);
 
       if (selector.isSetter()) {
         parameters.add(new jsAst.Parameter('value'));
@@ skipping 21 matching lines @@
       jsAst.Fun function = js.fun(parameters, body);
 
       jsAst.PropertyAccess property =
           js[isolateProperties][name];
 
       buffer.add(jsAst.prettyPrint(property.assign(function), compiler));
       buffer.add(N);
     }
   }
 
+  /**
+   * If [:invokeOn:] has been compiled, emit all the possible selector names
+   * that are intercepted into the [:interceptedNames:] top-level
+   * variable. The implementation of [:invokeOn:] will use it to
+   * determine whether it should call the method with an extra
+   * parameter.
+   */
+  void emitInterceptedNames(CodeBuffer buffer) {
+    if (!compiler.enabledInvokeOn) return;
+    String name = backend.namer.getName(backend.interceptedNames);
+    jsAst.PropertyAccess property = js[isolateProperties][name];
+
+    int index = 0;
+    List<jsAst.ArrayElement> elements = backend.usedInterceptors.map(
+      (Selector selector) {
+        jsAst.Literal str = js.string(namer.invocationName(selector));
+        return new jsAst.ArrayElement(index++, str);
+      }).toList();
+    jsAst.ArrayInitializer array = new jsAst.ArrayInitializer(
+        backend.usedInterceptors.length,
+        elements);
+
+    buffer.add(jsAst.prettyPrint(property.assign(array), compiler));
+    buffer.add(N);
+  }
+
   void emitInitFunction(CodeBuffer buffer) {
     jsAst.Fun fun = js.fun([], [
       js['$isolateProperties = {}'],
     ]
     ..addAll(buildDefineClassAndFinishClassFunctionsIfNecessary())
     ..addAll(buildLazyInitializerFunctionIfNecessary())
     ..addAll(buildFinishIsolateConstructor())
     );
     jsAst.FunctionDeclaration decl = new jsAst.FunctionDeclaration(
         new jsAst.VariableDeclaration('init'), fun);
@@ skipping 81 matching lines @@
 
       emitStaticFunctions(mainBuffer);
       emitStaticFunctionGetters(mainBuffer);
 
       emitRuntimeTypeSupport(mainBuffer);
       emitCompileTimeConstants(mainBuffer);
       // Static field initializations require the classes and compile-time
       // constants to be set up.
       emitStaticNonFinalFieldInitializations(mainBuffer);
       emitOneShotInterceptors(mainBuffer);
+      emitInterceptedNames(mainBuffer);
       emitGetInterceptorMethods(mainBuffer);
       emitLazilyInitializedStaticFields(mainBuffer);
 
       isolateProperties = isolatePropertiesName;
       // The following code should not use the short-hand for the
       // initialStatics.
       mainBuffer.add('var ${namer.CURRENT_ISOLATE}$_=${_}null$N');
 
       emitFinishIsolateConstructorInvocation(mainBuffer);
       mainBuffer.add('var ${namer.CURRENT_ISOLATE}$_='
@@ skipping 80 matching lines @@
 """;
 const String HOOKS_API_USAGE = """
 // The code supports the following hooks:
 // dartPrint(message)   - if this function is defined it is called
 //                        instead of the Dart [print] method.
 // dartMainRunner(main) - if this function is defined, the Dart [main]
 //                        method will not be invoked directly.
 //                        Instead, a closure that will invoke [main] is
 //                        passed to [dartMainRunner].
 """;