Implement named constructors and resolving of redirecting constructors and super-initializers.

frog/leg/scanner/class_element_parser.dart

Index: frog/leg/scanner/class_element_parser.dart
diff --git a/frog/leg/scanner/class_element_parser.dart b/frog/leg/scanner/class_element_parser.dart
index 256a48e48f03b9d3acab05153177a4c701e6842c..0594270ad69185fd5ac92706aa5e4ad625f7fc26 100644
--- a/frog/leg/scanner/class_element_parser.dart
+++ b/frog/leg/scanner/class_element_parser.dart
@@ -39,26 +39,42 @@ class MemberListener extends NodeListener {
                  [Element this.enclosingElement = null])
     : super(canceler, logger);
 
-  bool isConstructor(Identifier name) {
-    return enclosingElement !== null &&
-           enclosingElement.kind == ElementKind.CLASS &&
-           enclosingElement.name == name.source;
+  bool isConstructorName(Node nameNode) {
+    if (enclosingElement === null ||
+        enclosingElement.kind != ElementKind.CLASS) {
+      return false;
+    }
+    SourceString name;
+    if (nameNode.asIdentifier() != null) {
+      name = nameNode.asIdentifier().source;
+    } else {
+      Send send = nameNode.asSend();
+      name = send.receiver.asIdentifier().source;
+    }
+    return enclosingElement.name == name;
   }
 
   void endMethod(Token beginToken, Token endToken) {
     super.endMethod(beginToken, endToken);
     FunctionExpression method = popNode();
     pushNode(null);
-    Expression qualified = method.name;
-    Identifier name = qualified.asIdentifier();
-    if (name === null) {
-      canceler.cancel('qualified names are not implemented', node: qualified);
+    bool isConstructor = isConstructorName(method.name);
+    SourceString name;
+    if (method.name.asSend() != null) {

[ngeoffray, 2012/01/20 13:54:17]

I would put method.name in a variable (also used lines 61, 65, 66, 71).

[karlklose, 2012/01/20 14:11:36]

Done.

+      // TODO(karlklose): find a better place for the construction of the name.
+      Identifier receiver = method.name.asSend().receiver.asIdentifier();
+      Identifier selector = method.name.asSend().selector.asIdentifier();
+      SourceString className = receiver.source;
+      SourceString constructorName = selector.source;
+      name = new SourceString('$className.$constructorName');

[ahe, 2012/02/15 07:31:15]

The scanner and parser generally takes care to avoid concatenating strings. This
innocuous looking expression could be equivalent to something like this:

String x = new String.fromCharCodes(new Utf8Decoder(className.bytes,
className.offset, className.length).decodeRest());
String y = new String.fromCharCodes(new Utf8Decoder(constructorName.bytes,
constructorName.offset, constructorName.length).decodeRest());
StringBuffer sb = new StringBuffer();
sb.add(x);
sb.add(y);
name = new SourceString(sb.toString());

This means constructing seven temporary objects (the UTF8 decoder returns a
List<int>). Also, the bytes of each source string is copied three times.

Right now, I'm seeing a 14% improvement from using ByteArray on
vm_scanner_bench. However, when I try to use ByteArray in Leg, scanner
performance regress. So we're somehow losing more than 14% performance in
class_element_parser. I'm not sure that this particular change is responsible
for this regression, but it underlines the importance of being very careful
about these things.

Please don't forget to include me on changes to the scanner in the future.

[ahe, 2012/02/15 09:25:00]

I made some additional instrumentation and I can completely clear this
particular change of any adverse effects on the scanner performance of
hello_world.dart.

+    } else {
+      name = method.name.asIdentifier().source;
     }
-    ElementKind kind = isConstructor(name) ?
+    ElementKind kind = isConstructor ?
                        ElementKind.GENERATIVE_CONSTRUCTOR :
                        ElementKind.FUNCTION;
     Element memberElement =
-        new PartialFunctionElement(name.source, beginToken, endToken,
+        new PartialFunctionElement(name, beginToken, endToken,
                                    kind, method.modifiers, enclosingElement);
     enclosingElement.addMember(memberElement);
   }