Source in most stuff.

dart/frog/leg/elements/elements.dart

Index: dart/frog/leg/elements/elements.dart
diff --git a/dart/frog/leg/elements/elements.dart b/dart/frog/leg/elements/elements.dart
index 0306806b24e4de28b8d060c2cc21694c7fdd49b3..120d41e5bf0b1363d86993a731321f9fe3dfca3f 100644
--- a/dart/frog/leg/elements/elements.dart
+++ b/dart/frog/leg/elements/elements.dart
@@ -323,7 +323,11 @@ Type getType(TypeAnnotation typeAnnotation,
     // TODO(karlklose): substitute type parameters.
     return element.computeType(compiler);
   }
-  return compiler.types.lookup(name);
+  Type type = compiler.types.lookup(name);

[kasperl, 2012/02/15 09:22:30]

Would it be cleaner to have a way of querying if the types contains a certain
name and deal with that first? I'm always a bit worried when I see lookup
functions that happily return null.

[ahe, 2012/02/15 09:46:55]

Interesting difference of opinion here: I really prefer avoiding looking up
something twice. Or is it the name of the method that you don't like?

[kasperl, 2012/02/15 10:01:29]

Yeah, I think it would be neater with something like 

compiler.types.lookupIfAbsent(
  name, 
  () => compiler.types.dynamicType);

or maybe just move the logic into compiler.types.lookup. Usually I prefer having
something like lookup throw an error if it cannot find the thing you're looking
for because it is so easy to write code under that assumption.

[ahe, 2012/02/15 15:08:42]

Actually, this entire method is somewhat broken. I plan to overhaul this a some
point, but I'm not sure what to do. Karl and I had a conversation about this,
but we didn't come up with anything yet.

+  if (type === null) {
+    type = compiler.types.dynamicType;
+  }
+  return type;
 }
 
 class FunctionParameters {