Add a draft of traversing visitor which will analyse function.

lib/compiler/implementation/dart_backend.dart

+// Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file

[ahe, 2012/06/01 13:55:51]

Move this to a separate directory?

[Anton Muhin, 2012/06/01 15:09:04]

I can easily do it, but maybe (again maybe) let's wait until this file grows big
enough to have at least two files under this dir.

Again, if you think that single file dir is ok, I'll do it immediately.

[ahe, 2012/06/01 16:09:03]

I think it would be best with a subdirectory now.

[Anton Muhin, 2012/06/01 16:31:38]

Done.

+// 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.
+
+/**
+ * Visitor to gather conservative estimate of functions which
+ * can be invoked and classes which can be instantiated.
+ */
+class ReachabilityVisitor implements Visitor {
+  visitBlock(Block node) {}
+  visitBreakStatement(BreakStatement node) {}
+  visitCascade(Cascade node) {}
+  visitCascadeReceiver(CascadeReceiver node) {}
+  visitCaseMatch(CaseMatch node) {}
+  visitCatchBlock(CatchBlock node) {}
+  visitClassNode(ClassNode node) {
+    internalError('should not reach ClassNode');
+  }
+  visitConditional(Conditional node) {}
+  visitContinueStatement(ContinueStatement node) {}
+  visitDoWhile(DoWhile node) {}
+  visitEmptyStatement(EmptyStatement node) {}
+  visitExpressionStatement(ExpressionStatement node) {}
+  visitFor(For node) {}
+  visitForIn(ForIn node) {}
+  visitFunctionDeclaration(FunctionDeclaration node) {}
+  visitFunctionExpression(FunctionExpression node) {
+    // TODO(antonm): add a closure to working queue.
+    unimplemented('FunctionExpression is not supported');
+  }
+  visitIdentifier(Identifier node) {}
+  visitIf(If node) {}
+  visitLabel(Label node) {}
+  visitLabeledStatement(LabeledStatement node) {}
+  visitLiteralBool(LiteralBool node) {}
+  visitLiteralDouble(LiteralDouble node) {}
+  visitLiteralInt(LiteralInt node) {}
+  visitLiteralList(LiteralList node) {}
+  visitLiteralMap(LiteralMap node) {}
+  visitLiteralMapEntry(LiteralMapEntry node) {}
+  visitLiteralNull(LiteralNull node) {}
+  visitLiteralString(LiteralString node) {}
+  visitModifiers(Modifiers node) {}
+  visitNamedArgument(NamedArgument node) {}
+  visitNewExpression(NewExpression node) {
+    // TODO(antonm): update set of instantiated classes.
+    unimplemented('NewExpression is not supported');
+  }
+  visitNodeList(NodeList node) {}
+  visitOperator(Operator node) {}
+  visitParenthesizedExpression(ParenthesizedExpression node) {}
+  visitReturn(Return node) {}
+  visitScriptTag(ScriptTag node) {}
+  visitSend(Send node) {
+    // TODO(antonm): update working queue.
+    unimplemented('Send is not supported');
+  }
+  visitSendSet(SendSet node) {
+    // TODO(antonm): update working queue.
+    unimplemented('SendSet is not supported');
+  }
+  visitStringInterpolation(StringInterpolation node) {}
+  visitStringInterpolationPart(StringInterpolationPart node) {}
+  visitStringJuxtaposition(StringJuxtaposition node) {}
+  visitSwitchCase(SwitchCase node) {}
+  visitSwitchStatement(SwitchStatement node) {}
+  visitThrow(Throw node) {}
+  visitTryStatement(TryStatement node) {}
+  visitTypeAnnotation(TypeAnnotation node) {}
+  visitTypedef(Typedef node) {}
+  visitTypeVariable(TypeVariable node) {}
+  visitVariableDefinitions(VariableDefinitions node) {}
+  visitWhile(While node) {}
+
+  unimplemented(String reason) {
+    throw new CompilerCancelledException('not implemented: $reason');

[ahe, 2012/06/01 13:55:51]

I would prefer if you don't instantiate this exception directly. It is best to
always have a position, because these unimplemented methods have a tendency to
linger on and throw nasty errors in the face of real users (or just your
co-workers).

So you should always use compiler.cancel and pass in something that tracks a
position (in this case, a node).

[Anton Muhin, 2012/06/01 15:09:04]

Peter,

This unimplemented will disappear really soon.

Plus in CL pending in review, this visitor will have a reference to the
compiler, so it'll just redirect to it, so maybe it's ok to keep it in this for
for a very brief time, wdyt?

On 2012/06/01 13:55:51, ahe wrote:

[ahe, 2012/06/01 16:09:03]

Sounds good.

On 2012/06/01 15:09:04, antonmuhin wrote:

+  }
+
+  internalError(String reason) {
+    throw new CompilerCancelledException('internal error: $reason');
+  }
+}
+
+class DartBackend extends Backend {
+  final ReachabilityVisitor reachabilityVisitor;
+  DartBackend(Compiler compiler)
+      : reachabilityVisitor = new ReachabilityVisitor(),
+        super(compiler);
+
+  String codegen(WorkItem work) {
+    // Traverse AST to populate sets of reachable classes and functions.
+    FunctionExpression function = work.element.parseNode(compiler);
+    function.body.accept(new TraversingVisitor(reachabilityVisitor));
+  }
+
+  void processNativeClasses(world, libraries) {}
+  void assembleProgram() {
+    compiler.assembledCode = '';
+  }
+}