Mock up all remaining core library implementation classes.

dart/frog/leg/frog_leg.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.
 
 #library('frog_leg');
 
 #import('../../lib/uri/uri.dart');
 #import('../lang.dart', prefix: 'frog');
 #import('elements/elements.dart');
 #import('io/io.dart', prefix: 'io');
@@ skipping 90 matching lines @@
     Script script = currentScript();
     if (node !== null) {
       print(spanFromNode(node, script).toMessageString("cancel leg: $reason"));
     } else if (token !== null) {
       String tokenString = token.toString();
       int begin = token.charOffset;
       int end = begin + tokenString.length;
       print(script.file.getLocationMessage("cancel leg: $reason",
                                            begin, end, true));
     } else if (element !== null) {
+      if (element.position() === null) element = element.enclosingElement;

[kasperl, 2012/02/17 06:03:31]

Maybe add a comment on when this happens? What kind of elements do not have a
position? Would it make sense to have a helper on the element that runs out
through the enclosingElement chain until it finds an element with a position?

[ahe, 2012/02/17 07:40:47]

I'm not sure this API is where I want it. For example, if we need a synthetic
"this" element, it's position should probably be the span of the entire method
to which it corresponds. In other words, a Node, not a Token.

I think something is broken in the SSA builder and closurizer. It is creating
ad-hoc elements (which is really something the resolver should provide), and it
creates the wrong kind of elements using "new Element" and doesn't record
positions. Later it gets confused by these ad-hoc elements and tries to report
an internal error.

I think I need to write up something about how to use elements and how to
maintain a sane semantic model. Right now, I can see that the SSA builder and
the type checker are repeating work that earlier phases should take of.

[ngeoffray, 2012/02/17 10:03:50]

The thing is, the backend should not cancel on elements. It does not know
whether an element is part of the model or is a synthetized element created just
for its purposes. Another alternative that we talked about with Florian is to
have an interface BackendElement that all elements created by the backend should
implement.

Also, only the backend and the emitter see these synthetized elements. The
resolver and type checker never see them.

[ahe, 2012/02/17 16:26:46]

Nicolas and I went back to the drawing board, and I'll follow up on that later.

       withCurrentElement(element,
           () => cancel(reason: reason, token: element.position()));
     }
     if (throwOnError) {
       throw new AbortLeg(reason);
     }
     super.cancel(reason, node, token, instruction);
   }
 }
 
 class AbortLeg {
   final message;
   AbortLeg(this.message);
   toString() => 'Aborted due to --throw-on-error: $message';
 }