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 SETUP_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) {

[karlklose, 2013/06/19 14:37:05]

Would it make sense to replace operatorIs with a version taking a DartType and
use that instead?

[Johnni Winther, 2013/06/21 12:19:15]

I tried, but it made several of the original call sites awkward (they had to
call element.computeType(compiler) !!).

+    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 '${SETUP_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;
     }
   }
 }
 
-

[karlklose, 2013/06/19 14:37:05]

Is this intentional? See also l. 1018.

[Johnni Winther, 2013/06/21 12:19:15]

No. I often accidentally create too many blank lines, so I probably removed
these as part of a clean up of the ones I created.

 /**
  * 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;
+      }
+    }
+  }
+}