Revert "Support runtime check of function types."

sdk/lib/_internal/compiler/implementation/js_backend/namer.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.
 
 part of js_backend;
 
 /**
  * Assigns JavaScript identifiers to Dart variables, class-names and members.
  */
 class Namer implements ClosureNamer {
@@ skipping 155 matching lines @@
     if (_jsVariableReserved == null) {
       _jsVariableReserved = new Set<String>();
       _jsVariableReserved.addAll(javaScriptKeywords);
       _jsVariableReserved.addAll(reservedPropertySymbols);
       _jsVariableReserved.addAll(reservedGlobalSymbols);
     }
     return _jsVariableReserved;
   }
 
   final String CURRENT_ISOLATE;
-  String get GLOBAL_OBJECT => CURRENT_ISOLATE;
 
   final String getterPrefix = r'get$';
   final String setterPrefix = r'set$';
   final String metadataField = '@';
 
   /**
    * Map from top-level or static elements to their unique identifiers provided
    * by [getName].
    *
    * Invariant: Keys must be declaration elements.
@@ skipping 573 matching lines @@
   }
 
   String isolateStaticClosureAccess(Element element) {
     return "$CURRENT_ISOLATE.${getStaticClosureName(element)}";
   }
 
   String operatorIsPrefix() => r'$is';
 
   String operatorAsPrefix() => r'$as';
 
-  String operatorSignature() => r'$signature';
-
-  String functionTypeTag() => r'func';
-
-  String functionTypeVoidReturnTag() => r'void';
-
-  String functionTypeReturnTypeTag() => r'ret';
-
-  String functionTypeRequiredParametersTag() => r'args';
-
-  String functionTypeOptionalParametersTag() => r'opt';
-
-  String functionTypeNamedParametersTag() => r'named';
-
-  Map<FunctionType,String> functionTypeNameMap =
-      new Map<FunctionType,String>();
-  FunctionTypeNamer functionTypeNamer = new FunctionTypeNamer();
-
-  String getFunctionTypeName(FunctionType functionType) {
-    return functionTypeNameMap.putIfAbsent(functionType, () {
-      String proposedName = functionTypeNamer.computeName(functionType);
-      String freshName = getFreshName(proposedName, usedInstanceNames,
-                                      suggestedInstanceNames, ensureSafe: true);
-      return freshName;
-    });
-  }
-
-  String operatorIsType(DartType type) {
-    if (type.kind == TypeKind.FUNCTION) {
-      // TODO(erikcorry): Reduce from $isx to ix when we are minifying.
-      return '${operatorIsPrefix()}_${getFunctionTypeName(type)}';
-    }
-    return operatorIs(type.element);
-  }
-
   String operatorIs(Element element) {
     // TODO(erikcorry): Reduce from $isx to ix when we are minifying.
     return '${operatorIsPrefix()}${getRuntimeTypeName(element)}';
   }
 
   /*
    * Returns a name that does not clash with reserved JS keywords,
    * and also ensures it won't clash with other identifiers.
    */
   String _safeName(String name, Set<String> reserved) {
     if (reserved.contains(name) || name.startsWith(r'$')) {
       name = '\$$name';
     }
     assert(!reserved.contains(name));
     return name;
   }
 
   String substitutionName(Element element) {
     return '${operatorAsPrefix()}${getName(element)}';
   }
 
-  String signatureLocation(FunctionType type) {
-    ClassElement classElement = Types.getClassContext(type);
-    if (classElement != null) {
-      return '${isolateAccess(classElement)}';
-    } else {
-      return '${GLOBAL_OBJECT}';
-    }
-  }
-
-  String signatureName(FunctionType type) {
-    String signature = '${operatorSignature()}_${getFunctionTypeName(type)}';
-    return '${signatureLocation(type)}.$signature';
-  }
-
   String safeName(String name) => _safeName(name, jsReserved);
   String safeVariableName(String name) => _safeName(name, jsVariableReserved);
 
   SourceString operatorNameToIdentifier(SourceString name) {
     if (name == null) return null;
     String value = name.stringValue;
     if (value == null) {
       return name;
     } else if (value == '==') {
       return const SourceString(r'$eq');
@@ skipping 34 matching lines @@
     } else if (value == '-') {
       return const SourceString(r'$sub');
     } else if (value == 'unary-') {
       return const SourceString(r'$negate');
     } else {
       return name;
     }
   }
 }
 
+
 /**
  * Generator of names for [Constant] values.
  *
  * The names are stable under perturbations of the source.  The name is either a
  * short sequence of words, if this can be found from the constant, or a type
  * followed by a hash tag.
  *
  *     List_imX                // A List, with hash tag.
  *     C_Sentinel              // const Sentinel(),  "C_" added to avoid clash
  *                             //   with class name.
@@ skipping 153 matching lines @@
     String name = backend.rti.getRawTypeRepresentation(type);
     addIdentifier(name);
   }
 
   visitInterceptor(InterceptorConstant constant) {
     addRoot(constant.dispatchedType.element.name.slowToString());
     add('methods');
   }
 }
 
+
 /**
  * Generates canonical hash values for [Constant]s.
  *
  * Unfortunately, [Constant.hashCode] is not stable under minor perturbations,
  * so it can't be used for generating names.  This hasher keeps consistency
  * between runs by basing hash values of the names of elements, rather than
  * their hashCodes.
  */
 class ConstantCanonicalHasher implements ConstantVisitor<int> {
 
@@ skipping 125 matching lines @@
     hash = hash ^ (hash >> 6);
     return hash;
   }
 
   static int _finish(int hash) {
     hash = _MASK & (hash + (((_MASK >> 3) & hash) <<  3));
     hash = hash & (hash >> 11);
     return _MASK & (hash + (((_MASK >> 15) & hash) << 15));
   }
 }
-
-class FunctionTypeNamer extends DartTypeVisitor {
-  StringBuffer sb;
-
-  String computeName(DartType type) {
-    sb = new StringBuffer();
-    visit(type);
-    return sb.toString();
-  }
-
-  visit(DartType type) {
-    type.accept(this, null);
-  }
-
-  visitType(DartType type, _) {
-    sb.write(type.name.slowToString());
-  }
-
-  visitFunctionType(FunctionType type, _) {
-    visit(type.returnType);
-    sb.write('_');
-    for (Link<DartType> link = type.parameterTypes;
-         !link.isEmpty;
-         link = link.tail) {
-      sb.write('_');
-      visit(link.head);
-    }
-    bool first = false;
-    for (Link<DartType> link = type.optionalParameterTypes;
-         !link.isEmpty;
-         link = link.tail) {
-      if (!first) {
-        sb.write('_');
-      }
-      sb.write('_');
-      visit(link.head);
-      first = true;
-    }
-    if (!type.namedParameterTypes.isEmpty) {
-      first = false;
-      for (Link<DartType> link = type.namedParameterTypes;
-          !link.isEmpty;
-          link = link.tail) {
-        if (!first) {
-          sb.write('_');
-        }
-        sb.write('_');
-        visit(link.head);
-        first = true;
-      }
-    }
-  }
-}