Fix crash in dartc when given cyclic type variable bounds.

tests/language/src/CyclicTypeVariableTest.dart

Index: tests/language/src/CyclicTypeVariableTest.dart
diff --git a/tests/language/src/CyclicTypeVariableTest.dart b/tests/language/src/CyclicTypeVariableTest.dart
new file mode 100644
index 0000000000000000000000000000000000000000..d842252707d6df59d25a3e4e89a94320d532e6b2
--- /dev/null
+++ b/tests/language/src/CyclicTypeVariableTest.dart
@@ -0,0 +1,61 @@
+// 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.
+
+// Tests cyclic reference to type variables in type expressions
+
+class Base<T> {}
+
+class Derived extends Base<Derived> {}  // legal
+
+typedef void funcType<T 
+extends T /// 01: static type error

[gbracha, 2012/01/13 22:53:47]

Again, this is syntactically invalid.

[zundel, 2012/01/17 13:17:03]

Not a syntax error acc'd to the spec from what we can tell, did you see Miguel's
previous comment?

"Unless there is some other countering clause, I think that this is legal per
the
grammar in section 13.3.1 of v0.06 of the spec.

functionTypeAlias:
typedef functionPrefi
x typeParameters? formalParameterList ';'
;
"

Did it once exist and now has been removed?  There would be lots of 

[zundel, 2012/01/17 13:19:17]

(I can easily change the parser, but I think there would be a good deal of dead
code remove if this is no longer a feature.)

+>(T arg);
+
+class DerivedFunc extends Base<funcType<DerivedFunc>> { }
+
+
+interface A<S 
+extends S /// 02: static type error
+> {
+  S field;
+}
+
+interface B<U extends Base<U>> { // legal
+  U field;
+}
+
+class C1<V 
+extends V  /// 03: static type error
+> {
+  V field;
+}
+
+class C2<V
+extends V  /// 04: static type error
+> implements A<V> {
+  V field;
+}
+
+class D1<W extends Base<W>> {  // legal
+  W field;
+}
+
+class D2<W extends Base<W>> implements B<W>{   // legal
+  W field;
+}
+
+class E<X extends Base<funcType<X>>> { // legal
+
+  X field;
+}
+
+
+main() {
+  new C1<int>();
+  new C2<int>();
+  new D1<Derived>();
+  new D2<Derived>();
+  new E<DerivedFunc>();
+  funcType<Object> val = null;
+}