@@ -143,6 +143,8 @@ class EdgeBuilder extends GeneralizingAstVisitor<DecoratedType> {
       DartType elementType;
       if (element is MethodElement) {
         elementType = element.type;
+      } else if (element is ConstructorElement) {
+        elementType = element.type;
       } else {
         throw element.runtimeType; // TODO(paulberry)
       }
@@ -472,17 +474,22 @@ class EdgeBuilder extends GeneralizingAstVisitor<DecoratedType> {
   DecoratedType visitInstanceCreationExpression(
       InstanceCreationExpression node) {
     var callee = node.staticElement;
-    var calleeType = getOrComputeElementType(callee);
     var typeParameters = callee.enclosingElement.typeParameters;
-    if (typeParameters.isNotEmpty) {
-      // If the class has type parameters then we might need to substitute the
-      // appropriate type arguments.
-      // TODO(brianwilkerson)
-      _unimplemented(node, 'Instance creation expression with type arguments');
+    List<DecoratedType> decoratedTypeArguments;
+    var typeArguments = node.constructorName.type.typeArguments;
+    if (typeArguments != null) {
+      decoratedTypeArguments = typeArguments.arguments
+          .map((t) => _variables.decoratedTypeAnnotation(_source, t))
+          .toList();
+    } else {
+      decoratedTypeArguments = const [];
     }
-    _handleInvocationArguments(node, node.argumentList.arguments,
-        node.constructorName.type.typeArguments, calleeType, typeParameters);
-    return calleeType.returnType;
+    var createdType = DecoratedType(node.staticType, _graph.never,
+        typeArguments: decoratedTypeArguments);
+    var calleeType = getOrComputeElementType(callee, targetType: createdType);
+    _handleInvocationArguments(node, node.argumentList.arguments, typeArguments,
+        calleeType, typeParameters);
+    return createdType;
   }
 
   @override
 
@@ -878,6 +878,26 @@ int f(int x) {
     await _checkSingleFileChanges(content, expected);
   }
 
+  test_instance_creation_generic() async {
+    var content = '''
+class C<T> {
+  C(T t);
+}
+main() {
+  C<int> c = C<int>(null);
+}
+''';
+    var expected = '''
+class C<T> {
+  C(T t);
+}
+main() {
+  C<int?> c = C<int?>(null);
+}
+''';
+    await _checkSingleFileChanges(content, expected);
+  }
+
   test_instanceCreation_noTypeArguments_noParameters() async {
     var content = '''
 void main() {
 
@@ -1147,6 +1147,35 @@ C f(C c) => c..[0];
     assertEdge(decoratedTypeAnnotation('C c').node, never, hard: true);
   }
 
+  test_instanceCreation_generic() async {
+    await analyze('''
+class C<T> {}
+C<int> f() => C<int>();
+''');
+    assertEdge(decoratedTypeAnnotation('int>(').node,
+        decoratedTypeAnnotation('int> f').node,
+        hard: false);
+  }
+
+  test_instanceCreation_generic_parameter() async {
+    await analyze('''
+class C<T> {
+  C(T t);
+}
+f(int i) => C<int>(i/*check*/);
+''');
+    var nullable_i = decoratedTypeAnnotation('int i').node;
+    var nullable_c_t = decoratedTypeAnnotation('C<int>').typeArguments[0].node;
+    var nullable_t = decoratedTypeAnnotation('T t').node;
+    var check_i = checkExpression('i/*check*/');
+    var nullable_c_t_or_nullable_t =
+        check_i.edges.single.destinationNode as NullabilityNodeForSubstitution;
+    expect(nullable_c_t_or_nullable_t.innerNode, same(nullable_c_t));
+    expect(nullable_c_t_or_nullable_t.outerNode, same(nullable_t));
+    assertNullCheck(check_i,
+        assertEdge(nullable_i, nullable_c_t_or_nullable_t, hard: true));
+  }
+
   test_instanceCreation_parameter_named_optional() async {
     await analyze('''
 class C {