Stub implementation of patch invariants for the patch refactoring.

lib/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.
 
 /**
  * A function element that represents a closure call. The signature is copied
  * from the given element.
  */
 class ClosureInvocationElement extends FunctionElement {
   ClosureInvocationElement(SourceString name,
@@ skipping 480 matching lines @@
         && compiler.codegenWorld.hasInvokedSetter(member, compiler);
   }
 
   String compiledFieldName(Element member) {
     assert(member.isField());
     return member.isNative()
         ? member.name.slowToString()
         : namer.getName(member);
   }
 
+  /**
+   * Documentation wanted -- johnniwinther
+   *
+   * Invariant: [member] must be a declaration element.
+   */
   void addInstanceMember(Element member,
                          DefineMemberFunction defineInstanceMember) {
+    assert(invariant(member, member.isDeclaration));
     // TODO(floitsch): we don't need to deal with members of
     // uninstantiated classes, that have been overwritten by subclasses.
 
     if (member.isFunction()
         || member.isGenerativeConstructorBody()
         || member.isGetter()
         || member.isSetter()) {
       if (member.modifiers !== null && member.modifiers.isAbstract()) return;
       CodeBuffer codeBuffer = compiler.codegenWorld.generatedCode[member];
       if (codeBuffer == null) return;
@@ skipping 24 matching lines @@
     } else {
       SourceString helper = compiler.backend.getCheckedModeHelper(type);
       Element helperElement = compiler.findHelper(helper);
       String helperName = namer.isolateAccess(helperElement);
       String additionalArgument = namer.operatorIs(type.element);
       return " set\$$fieldName: function(v) { "
           "this.$fieldName = $helperName(v, '$additionalArgument'); }";
     }
   }
 
+  /**
+   * Documentation wanted -- johnniwinther
+   *
+   * Invariant: [classElement] must be a declaration element.
+   */
   List<String> emitClassFields(ClassElement classElement, CodeBuffer buffer) {
+    assert(invariant(classElement, classElement.isDeclaration));
     // If the class is never instantiated we still need to set it up for
     // inheritance purposes, but we can simplify its JavaScript constructor.
     bool isInstantiated =
         compiler.codegenWorld.instantiatedClasses.contains(classElement);
     List<String> checkedSetters = <String>[];
 
     bool isFirstField = true;
     void addField(ClassElement enclosingClass, Element member) {
       assert(!member.isNative());
+      assert(invariant(classElement, member.isDeclaration));
 
       LibraryElement library = member.getLibrary();
       SourceString name = member.name;
       bool isPrivate = name.isPrivate();
       // See if we can dynamically create getters and setters.
       // We can only generate getters and setters for [classElement] since
       // the fields of super classes could be overwritten with getters or
       // setters.
       bool needsDynamicGetter = false;
       bool needsDynamicSetter = false;
@@ skipping 44 matching lines @@
     // generate the field getter/setter dynamically. Since this is only
     // allowed on fields that are in [classElement] we don't need to visit
     // superclasses for non-instantiated classes.
     classElement.forEachInstanceField(
         addField,
         includeBackendMembers: true,
         includeSuperMembers: isInstantiated && !classElement.isNative());
     return checkedSetters;
   }
 
+  /**
+   * Documentation wanted -- johnniwinther
+   *
+   * Invariant: [classElement] must be a declaration element.
+   */
   void emitInstanceMembers(ClassElement classElement,
                            CodeBuffer buffer,
                            bool needsLeadingComma) {
+    assert(invariant(classElement, classElement.isDeclaration));
     bool needsComma = needsLeadingComma;
     void defineInstanceMember(String name, CodeBuffer memberBuffer) {
       if (needsComma) buffer.add(',');
       needsComma = true;
       buffer.add('\n');
       buffer.add(' $name: ');
       buffer.add(memberBuffer);
     }
 
     classElement.forEachMember(includeBackendMembers: true,
                                f: (ClassElement enclosing, Element member) {
+      assert(invariant(classElement, member.isDeclaration));
       if (member.isInstanceMember()) {
         addInstanceMember(member, defineInstanceMember);
       }
     });
 
     generateIsTestsOn(classElement, (Element other) {
       String code;
       if (nativeEmitter.requiresNativeIsCheck(other)) {
         code = 'function() { return true; }';
       } else {
         code = 'true';
       }
       CodeBuffer typeTestBuffer = new CodeBuffer();
       typeTestBuffer.add(code);
       defineInstanceMember(namer.operatorIs(other), typeTestBuffer);
     });
 
     if (classElement === compiler.objectClass && 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(defineInstanceMember);
       }
     }
   }
 
+  /**
+   * Documentation wanted -- johnniwinther
+   *
+   * Invariant: [classElement] must be a declaration element.
+   */
   void generateClass(ClassElement classElement, CodeBuffer buffer) {
+    assert(invariant(classElement, classElement.isDeclaration));
     if (classElement.isNative()) {
       nativeEmitter.generateNativeClass(classElement);
       return;
     } else {
       // TODO(ngeoffray): Instead of switching between buffer, we
       // should create code sections, and decide where to emit them at
       // the end.
       buffer = mainBuffer;
     }
 
@@ skipping 175 matching lines @@
       addParameterStubs(callElement, (String name, CodeBuffer value) {
         buffer.add('$fieldAccess.$name = $value;\n');
       });
       // If a static function is used as a closure we need to add its name
       // in case it is used in spawnFunction.
       String fieldName = namer.STATIC_CLOSURE_NAME_NAME;
       buffer.add('$fieldAccess.$fieldName = "$staticName";\n');
     }
   }
 
+  /**
+   * Documentation wanted -- johnniwinther
+   *
+   * Invariant: [member] must be a declaration element.
+   */
   void emitDynamicFunctionGetter(FunctionElement member,
                                  DefineMemberFunction defineInstanceMember) {
+    assert(invariant(member, member.isDeclaration));
     // For every method that has the same name as a property-get we create a
     // getter that returns a bound closure. Say we have a class 'A' with method
     // 'foo' and somewhere in the code there is a dynamic property get of
     // 'foo'. Then we generate the following code (in pseudo Dart/JavaScript):
     //
     // class A {
     //    foo(x, y, z) { ... } // Original function.
     //    get foo { return new BoundClosure499(this, "foo"); }
     // }
     // class BoundClosure499 extends Closure {
@@ skipping 62 matching lines @@
 
     // And finally the getter.
     String getterName = namer.getterName(member.getLibrary(), member.name);
     String targetName = namer.instanceMethodName(member);
     CodeBuffer getterBuffer = new CodeBuffer();
     getterBuffer.add(
         "function() { return new $closureClass(this, '$targetName'); }");
     defineInstanceMember(getterName, getterBuffer);
   }
 
+  /**
+   * Documentation wanted -- johnniwinther
+   *
+   * Invariant: [member] must be a declaration element.
+   */
   void emitCallStubForGetter(Element member,
                              Set<Selector> selectors,
                              DefineMemberFunction defineInstanceMember) {
+    assert(invariant(member, member.isDeclaration));
+    LibraryElement memberLibrary = member.getLibrary();
     String getter;
     if (member.isGetter()) {
       getter = "this.${namer.getterName(member.getLibrary(), member.name)}()";
     } else {
-      String name = namer.instanceFieldName(member.getLibrary(), member.name);
+      String name = namer.instanceFieldName(memberLibrary, member.name);
       getter = "this.$name";
     }
     for (Selector selector in selectors) {
       if (selector.applies(member, compiler)) {
         String invocationName =
-            namer.instanceMethodInvocationName(member.getLibrary(), member.name,
+            namer.instanceMethodInvocationName(memberLibrary, member.name,
                                                selector);
         SourceString callName = Namer.CLOSURE_INVOCATION_NAME;
         String closureCallName =
-            namer.instanceMethodInvocationName(member.getLibrary(), callName,
+            namer.instanceMethodInvocationName(memberLibrary, callName,
                                                selector);
         List<String> arguments = <String>[];
         for (int i = 0; i < selector.argumentCount; i++) {
           arguments.add("arg$i");
         }
         String joined = Strings.join(arguments, ", ");
         CodeBuffer getterBuffer = new CodeBuffer();
         getterBuffer.add(
             "function($joined) { return $getter.$closureCallName($joined); }");
         defineInstanceMember(invocationName, getterBuffer);
@@ skipping 71 matching lines @@
   void emitMakeConstantList(CodeBuffer buffer) {
     buffer.add(namer.ISOLATE);
     buffer.add(@'''.makeConstantList = function(list) {
   list.immutable$list = true;
   list.fixed$length = true;
   return list;
 };
 ''');
   }
 
+  /**
+   * Documentation wanted -- johnniwinther
+   *
+   * Invariant: [member] must be a declaration element.
+   */
   void emitExtraAccessors(Element member,
                           DefineMemberFunction defineInstanceMember) {
+    assert(invariant(member, member.isDeclaration));
     if (member.isGetter() || member.isField()) {
       Set<Selector> selectors = compiler.codegenWorld.invokedNames[member.name];
       if (selectors !== null && !selectors.isEmpty()) {
         emitCallStubForGetter(member, selectors, defineInstanceMember);
       }
     } else if (member.isFunction()) {
       if (compiler.codegenWorld.hasInvokedGetter(member, compiler)) {
         emitDynamicFunctionGetter(member, defineInstanceMember);
       }
     }
@@ skipping 313 matching lines @@
 const String HOOKS_API_USAGE = """
 // Generated by dart2js, the Dart to JavaScript compiler.
 // 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].
 """;