Some cleanups to Frog to avoid looking up its builtin types too much

frog/gen.dart

 // Copyright (c) 2011, 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.
 
 /**
  * Top level generator object for writing code and keeping track of
  * dependencies.
  *
  * Should have two compilation models, but only one implemented so far.
  *
@@ skipping 166 matching lines @@
       var filename = basename(file.filename);
       writer.comment('//  ********** Natives $filename **************');
       writer.writeln(file.text);
     }
     lib.topType.markUsed(); // TODO(jimhug): EGREGIOUS HACK
 
     for (var type in _orderValues(lib.types)) {
       // TODO(jmesserly): we can't accurately track if DOM types are
       // created or not, so we need to prepare to handle them.
       // This should be fixed by tightening up the return types in DOM.
-      if ((type.isUsed || type.library == world.dom
+      if ((type.isUsed || type.library.isDom
           || type.isHiddenNativeType) && type.isClass) {
         writeType(type);
 
         if (type.isGeneric) {
           for (var ct in _orderValues(type._concreteTypes)) {
             writeType(ct);
           }
         }
       } else if (type.isFunction && type.varStubs.length > 0) {
         // Emit stubs on "Function" or hidden types if needed
@@ skipping 35 matching lines @@
     }
 
     if (checkType.isChecked) {
       String body = 'return this';
       String checkName = 'assert\$${checkType.jsname}';
       if (!isSubtype) {
         // Get the code to throw a TypeError.
         // TODO(jmesserly): it'd be nice not to duplicate this code, and instead
         // be able to refer to the JS function.
         body = world.objectType.varStubs[checkName].body;
-      } else if (onType.name == 'StringImplementation' ||
-          onType.name == 'NumImplementation') {
+      } else if (onType == world.stringImplType
+          || onType == world.numImplType) {
         body = 'return ${onType.nativeType.name}(this)';
       }
       writer.writeln(_prototypeOf(onType, checkName) + ' = function(){$body};');
     }
   }
 
   writeType(Type type) {
     if (type.isWritten) return;
 
     type.isWritten = true;
@@ skipping 294 matching lines @@
 
   _usedDynamicDispatchOnType(Type type) {
     if (typesWithDynamicDispatch == null) typesWithDynamicDispatch = new Set();
     typesWithDynamicDispatch.add(type);
   }
 
   writeDynamicDispatchMetadata() {
     if (typesWithDynamicDispatch == null) return;
     writer.comment('// ${typesWithDynamicDispatch.length} dynamic types.');
 
-    typeTag(type) => type.definition.nativeType.name;
-
     // Build a pre-order traversal over all the types and their subtypes.
     var seen = new Set();
     var types = [];
     visit(type) {
       if (seen.contains(type)) return;
       seen.add(type);
       for (final subtype in _orderCollectionValues(type.directSubtypes)) {
         visit(subtype);
       }
       types.add(type);
@@ skipping 22 matching lines @@
     // Dart objects could be easily excluded, then we might be able to simplify
     // the test, replacing dozens of HTMLxxxElement types with the regexp
     // /HTML.*Element/.
 
     var varNames = [];  // temporary variables for common substrings.
     var varDefns = {};  // var -> expression
     var tagDefns = {};  // tag -> expression (a string or a variable)
 
     makeExpression(type) {
       var expressions = [];  // expression fragments for this set of type keys.
-      var subtags = [typeTag(type)];  // TODO: Remove if type is abstract.
+      var subtags = [type.nativeName];  // TODO: Remove if type is abstract.
       walk(type) {
         for (final subtype in _orderCollectionValues(type.directSubtypes)) {
-          var tag = typeTag(subtype);
+          var tag = subtype.nativeName;
           var existing = tagDefns[tag];
           if (existing == null) {
             subtags.add(tag);
             walk(subtype);
           } else {
             if (varDefns.containsKey(existing)) {
               expressions.add(existing);
             } else {
               var varName = 'v${varNames.length}/*${tag}*/';
               varNames.add(varName);
@@ skipping 10 matching lines @@
       var expression;
       if (expressions.length == 1) {
         expression = expressions[0];
       } else {
         expression = "[${Strings.join(expressions, ',')}].join('|')";
       }
       return expression;
     }
 
     for (final type in dispatchTypes) {
-      tagDefns[typeTag(type)] = makeExpression(type);
+      tagDefns[type.nativeName] = makeExpression(type);
     }
 
     // Write out a thunk that builds the metadata.
 
     if (!tagDefns.isEmpty()) {
       writer.enterBlock('(function(){');
 
       for (final varName in varNames) {
         writer.writeln('var ${varName} = ${varDefns[varName]};');
       }
 
       writer.enterBlock('var table = [');
       writer.comment(
           '// [dynamic-dispatch-tag, '
           + 'tags of classes implementing dynamic-dispatch-tag]');
       for (final type in dispatchTypes) {
-        writer.writeln("['${typeTag(type)}', ${tagDefns[typeTag(type)]}],");
+        writer.writeln("['${type.nativeName}', ${tagDefns[type.nativeName]}],");
       }
       writer.exitBlock('];');
       writer.writeln('\$dynamicSetMetadata(table);');
 
       writer.exitBlock('})();');
     }
   }
 
   /** Order a list of values in a Map by SourceSpan, then by name. */
   List _orderValues(Map map) {
@@ skipping 679 matching lines @@
     meth.resolve();
     return meth;
   }
 
   visitBool(Expression node) {
     // Boolean conversions in if/while/do/for/conditions require non-null bool.
 
     // TODO(jmesserly): why do we have this rule? It seems inconsistent with
     // the rest of the type system, and just causes bogus asserts unless all
     // bools are initialized to false.
-    return visitValue(node).convertTo(this, world.nonNullBool, node);
+    return visitValue(node).convertTo(this, world.nonNullBool);
   }
 
   visitValue(Expression node) {
     if (node == null) return null;
 
     var value = node.visit(this);
     value.checkFirstClass(node.span);
     return value;
   }
 
   /**
    * Visit [node] and ensure statically or with an runtime check that it has the
    * expected type (if specified).
    */
   visitTypedValue(Expression node, Type expectedType) {
     final val = visitValue(node);
-    return expectedType == null ? val : val.convertTo(this, expectedType, node);
+    return expectedType == null ? val : val.convertTo(this, expectedType);
   }
 
   visitVoid(Expression node) {
     // TODO(jmesserly): should we generalize this?
     if (node is PostfixExpression) {
       var value = visitPostfixExpression(node, isVoid: true);
       value.checkFirstClass(node.span);
       return value;
     } else if (node is BinaryExpression) {
       var value = visitBinaryExpression(node, isVoid: true);
@@ skipping 40 matching lines @@
 
       if (value == null) {
         if (_scope.reentrant) {
           // To preserve block scoping, we need to ensure the variable is
           // reinitialized each time the block is entered.
           writer.write('${val.code} = null');
         } else {
           writer.write('${val.code}');
         }
       } else {
-        value = value.convertTo(this, type, node.values[i]);
+        value = value.convertTo(this, type);
         writer.write('${val.code} = ${value.code}');
       }
     }
     writer.writeln(';');
     return false;
 
   }
 
   bool visitFunctionDefinition(FunctionDefinition node) {
     var meth = _makeLambdaMethod(node.name.name, node);
@@ skipping 683 matching lines @@
 
       // Otherwise treat it as a field.
       // This makes for nicer code in the $op= case
     }
 
     if (x.isFinal) {
       world.error('final variable "${x.code}" is not assignable',
           position.span);
     }
 
-    y = y.convertTo(this, x.type, yn);
+    y = y.convertTo(this, x.type);
 
     if (kind == 0) {
       x = captureOriginal(x);
       return new Value(y.type, '${x.code} = ${y.code}', position.span);
     } else if (x.type.isNum && y.type.isNum && (kind != TokenKind.TRUNCDIV)) {
       // Process everything but ~/ , which has no equivalent JS operator
       x = captureOriginal(x);
       // Very localized optimization for numbers!
       final op = TokenKind.kindToString(kind);
       return new Value(y.type, '${x.code} $op= ${y.code}', position.span);
@@ skipping 83 matching lines @@
           var assignValue = _visitAssign(kind, node.self, operand, node, null);
           return new Value(assignValue.type, '(${assignValue.code})',
               node.span);
         }
       case TokenKind.NOT:
         // TODO(jimhug): Issue #359 seeks to clarify this behavior.
         if (value.type.isBool && value.isConst) {
           var newVal = !value.actualValue;
           return new EvaluatedValue(value.type, newVal, '${newVal}', node.span);
         } else {
-          var newVal = value.convertTo(this, world.nonNullBool, node);
+          var newVal = value.convertTo(this, world.nonNullBool);
           return new Value(newVal.type, '!${newVal.code}', node.span);
         }
 
       case TokenKind.ADD:
         // TODO(jimhug): Issue #359 seeks to clarify this behavior.
-        return value.convertTo(this, world.numType, node);
+        return value.convertTo(this, world.numType);
 
       case TokenKind.SUB:
       case TokenKind.BIT_NOT:
         if (node.op.kind == TokenKind.BIT_NOT) {
           return value.invoke(this, ':bit_not', node, Arguments.EMPTY);
         } else if (node.op.kind == TokenKind.SUB) {
           return value.invoke(this, ':negate', node, Arguments.EMPTY);
         } else {
           world.internalError('unimplemented: unary ${node.op}',
             node.span);
@@ skipping 100 matching lines @@
         world.error('can\'t use const on a non-const constructor', node.span);
       }
       for (var arg in node.arguments) {
         if (!visitValue(arg.value).isConst) {
           world.error('const constructor expects const arguments', arg.span);
         }
       }
     }
 
     // Call the constructor on the type we want to construct.
-    // NOTE: this is important for correct checking of factories.
+    // NOTE: this is important for correct type checking of factories.
     // If the user calls "new Interface()" we want the result type to be the
     // interface, not the class.
     var target = new Value.type(type, typeRef.span);
     return m.invoke(this, node, target, _makeArgs(node.arguments));
   }
 
   visitListExpression(ListExpression node) {
     // TODO(jimhug): Use node.type or other type inference here.
     var argsCode = [];
     var argValues = [];
@@ skipping 13 matching lines @@
           world.error('const list can only contain const values', item.span);
           argsCode.add(arg.code);
         } else {
           argsCode.add(arg.canonicalCode);
         }
       } else {
         argsCode.add(arg.code);
       }
     }
 
-    world.coreimpl.types['ListFactory'].markUsed();
+    world.listFactoryType.markUsed();
 
     final code = '[${Strings.join(argsCode, ", ")}]';
     var value = new Value(world.listType, code, node.span);
     if (node.isConst) {
-      final immutableList = world.coreimpl.types['ImmutableList'];
+      final immutableList = world.immutableListType;
       final immutableListCtor = immutableList.getConstructor('from');
       final result = immutableListCtor.invoke(this, node,
           new Value.type(value.type, node.span), new Arguments(null, [value]));
       value = world.gen.globalForConst(
           new ConstListValue(immutableList, argValues, 'const $code',
               result.code, node.span),
           argValues);
     }
     return value;
   }
@@ skipping 151 matching lines @@
         }
         // No need to concat empty strings except the first.
         if (items.length == 0 || (code != "''" && code != '""')) {
           items.add(code);
         }
       }
       return new Value(type, '(${Strings.join(items, " + ")})', node.span);
     }
 
     if (node.value is num) {
-      world.coreimpl.types['NumImplementation'].markUsed();
+      world.numImplType.markUsed();
     }
 
     var text = node.text;
     // TODO(jimhug): Confirm that only strings need possible translation
     if (type.isString) {
-      world.coreimpl.types['StringImplementation'].markUsed();
+      world.stringImplType.markUsed();
 
       if (text.startsWith('@')) {
         text = _escapeString(parseStringLiteral(text));
         text = '"$text"';
       } else if (isMultilineString(text)) {
         // convert multi-line strings into single-line
         text = parseStringLiteral(text);
         // TODO(jimhug): What about \r?
         text = text.replaceAll('\n', '\\n');
         text = toDoubleQuote(text);
@@ skipping 123 matching lines @@
       result.add(new Value(world.varType, '\$$i', null, /*needsTemp:*/false));
     }
     for (int i = bareCount; i < length; i++) {
       var name = getName(i);
       if (name == null) name = '\$$i';
       result.add(new Value(world.varType, name, null, /*needsTemp:*/false));
     }
     return new Arguments(nodes, result);
   }
 }