It's an error if to instantiate a subclass of a malbounded type,or a type variable.

docs/language/dartLangSpec.tex

 \documentclass{article}
 \usepackage{epsfig}
 \usepackage{dart}
 \usepackage{bnf}
 \usepackage{hyperref}
 \newcommand{\code}[1]{{\sf #1}}
 \title{Dart Programming Language  Specification \\
 {\large Draft Version 0.71}}
 \author{The Dart Team}
 \begin{document}
@@ skipping 493 matching lines @@
 \ref{return}: Added warning if \RETURN{} without expression mixed with \RETURN{} with an expression.
 
 \ref{exports}: Ensure that exports treat \code{dart:} libs specially, like imports do.
 
 \ref{typePromotion}: Added notion of type promotion.
 
 \ref{typedef}: Banned all recursion in typedefs.
 
 \subsubsection{Changes Since Version 0.7}
 
+\ref{new}: Instantiating subclasses of malbounded types is a dynamic error.
+
 \ref{leastUpperBounds}:  Extended LUBs to all types.
 
 
 
 \section{Notation}
 \label{notation}
 
 We distinguish between normative and non-normative text. Normative text defines the rules of Dart. It is given in this font. At this time, non-normative text includes:
 \begin{itemize}
 \item[Rationale] Discussion of the motivation for language design decisions appears in italics. \rationale{Distinguishing normative from non-normative helps clarify what part of the text is binding and what part is merely expository.}
@@ skipping 2639 matching lines @@
 \end{itemize}
 
 If $R$ is a generic with $l \ne m$ type parameters then for $ i \in 1 .. l$, let $V_i =  \DYNAMIC{}$. In any other case, let $V_i = U_i$ for $ i \in 1 .. m$.  
 
 Evaluation of $e$ proceeds as follows:
 
 First, the argument list $(a_1, \ldots , a_n, x_{n+1}: a_{n+1}, \ldots , x_{n+k}: a_{n+k})$ is evaluated. 
 
 Then, if $q$ is a non-factory constructor of an abstract class then an \code{AbstractClassInstantiationError} is thrown.
 
-If $T$  is malformed a dynamic error occurs. In checked mode, if $T$ is malbounded a dynamic error occurs.
+If $T$  is malformed or if $T$ is type variable a dynamic error occurs. In checked mode, if $T$ or any of its superclasses is malbounded a dynamic error occurs.

[regis, 2013/10/16 00:48:34]

is *a* type variable

Can a class be malbounded? Would supertypes instead of superclasses be better?
Oh, that is not better, because it would include implemented interface types,
which are not a problem.

[gbracha, 2013/10/16 00:54:40]

Done.

  Otherwise, if $q$ is not defined or not accessible, a \code{NoSuchMethodError} is thrown.  If $q$ has  less than $n$ positional parameters or more than $n$ required parameters, or if $q$ lacks any of the keyword parameters $\{ x_{n+1}, \ldots, x_{n+k}\}$ a \code{NoSuchMethodError} is thrown.
 
 Otherwise, if $q$ is a generative constructor (\ref{generativeConstructors}), then:
 
 %Let $T_i$ be the type parameters of $R$ (if any) and let $B_i$ be the bound of $T_i, 1 \le i \le l$.
 %In checked mode, it is a dynamic type error if  $V_i$ is not a subtype of  $[V_1,  \ldots, V_l/T_1,  \ldots, T_l]B_i,  i \in 1.. l$.
 
 \commentary{Note that it this point we are assured that the number of actual type arguments match the number of formal type parameters.}
 
 A fresh instance (\ref{generativeConstructors}), $i$,  of class $R$ is allocated. For each instance variable $f$ of $i$,  if the variable declaration of $f$ has an initializer expression $e_f$, then $e_f$ is evaluated to an object $o_f$ and $f$ is bound to $o_f$. Otherwise $f$ is bound to \NULL{}.
@@ skipping 2428 matching lines @@
 %Likewise, we could opt to ignore malformed types entirely in checked mode.
 
 %For now, we have opted to treat a malformed type as an error type that has no subtypes or supertypes, and which causes a runtime error when tested against any other type.
 }
 
 \commentary{
 Here is an example involving malbounded types:
 }
 
 \begin{dartCode}
-\INTERFACE{} I$<$T \EXTENDS{} num$>$ \{\}
-\INTERFACE{} J \{\}
+\CLASS{} I$<$T \EXTENDS{} num$>$ \{\}
+\CLASS{} J \{\}
 
 \CLASS{} A$<$T$>$ \IMPLEMENTS{} J,  I$<$T$>$ // type warning: T is not a subtype of num
 \{ ...
 \} 
 \end{dartCode}
 
 \commentary{Given the declarations above, the following}
 
 \begin{dartCode}
 I x = \NEW{} A$<$String$>$(); 
@@ skipping 489 matching lines @@
 \item The names of compile time constant variables never use lower case letters. If they consist of multiple words, those words are separated by underscores. Examples: PI,  I\_AM\_A\_CONSTANT.
 \item The names of functions (including getters, setters, methods and local or library functions) and non-constant variables begin with a lowercase letter. If the name consists of multiple words, each  word (except the first) begins with an uppercase letter.  No other uppercase letters are used. Examples: camlCase, dart4TheWorld
 \item The names of types (including classes and type aliases) begin with an upper case letter.  If the name consists of multiple words, each  word  begins with an uppercase letter.  No other uppercase letters are used. Examples: CamlCase, Dart4TheWorld.
 \item The names of type variables are short (preferably single letter). Examples: T, S, K, V , E.
 \item The names of libraries or library prefixes never use upper case letters. If they consist of multiple words, those words are separated by underscores. Example: my\_favorite\_library.
 \end{itemize}
 }
 
 
 \end{document}