diff --git a/src/compiler/factory.ts b/src/compiler/factory.ts
index ec5ac638605..3c368db57fa 100644
--- a/src/compiler/factory.ts
+++ b/src/compiler/factory.ts
@@ -710,6 +710,26 @@ namespace ts {
         return createVoid(createLiteral(0));
     }
 
+    export function createImportDeclaration(importClause: ImportClause, moduleSpecifier?: Expression, location?: TextRange): ImportDeclaration {
+        const node = <ImportDeclaration>createNode(SyntaxKind.ImportDeclaration, location);
+        node.importClause = importClause;
+        node.moduleSpecifier = moduleSpecifier;
+        return node;
+    }
+
+    export function createImportClause(name: Identifier, namedBindings: NamedImportBindings, location?: TextRange): ImportClause {
+        const node = <ImportClause>createNode(SyntaxKind.ImportClause, location);
+        node.name = name;
+        node.namedBindings = namedBindings;
+        return node;
+    }
+
+    export function createNamedImports(elements: NodeArray<ImportSpecifier>, location?: TextRange): NamedImports {
+        const node = <NamedImports>createNode(SyntaxKind.NamedImports, location);
+        node.elements = elements;
+        return node;
+    }
+
     export function createMemberAccessForPropertyName(target: Expression, memberName: PropertyName, location?: TextRange): MemberExpression {
         if (isIdentifier(memberName)) {
             return createPropertyAccess(target, getSynthesizedClone(memberName), location);
diff --git a/src/compiler/transformers/module/es6.ts b/src/compiler/transformers/module/es6.ts
index f513ac36dbb..944e8cd6b5d 100644
--- a/src/compiler/transformers/module/es6.ts
+++ b/src/compiler/transformers/module/es6.ts
@@ -19,21 +19,64 @@ namespace ts {
             return node;
         }
 
-        function visitor(node: Node) {
+        function visitor(node: Node): VisitResult<Node> {
             switch (node.kind) {
                 case SyntaxKind.ImportDeclaration:
                     return visitImportDeclaration(<ImportDeclaration>node);
+                case SyntaxKind.ImportClause:
+                    return visitImportClause(<ImportClause>node);
+                case SyntaxKind.NamedImports:
+                case SyntaxKind.NamespaceImport:
+                    return visitNamedBindings(<NamedImportBindings>node);
+                case SyntaxKind.ImportSpecifier:
+                    return visitImportSpecifier(<ImportSpecifier>node);
             }
 
             return node;
         }
 
         function visitImportDeclaration(node: ImportDeclaration) {
-            if (node.importClause && !resolver.isReferencedAliasDeclaration(node.importClause, /*checkChildren*/ true)) {
-                return undefined;
+            if (node.importClause) {
+                const newImportClause = visitNode(node.importClause, visitor, isImportClause);
+                if (!newImportClause.name && !newImportClause.namedBindings) {
+                    return undefined;
+                }
+                else if (newImportClause !== node.importClause) {
+                    return createImportDeclaration(newImportClause, node.moduleSpecifier);
+                }
             }
-
             return node;
         }
+
+        function visitImportClause(node: ImportClause): ImportClause {
+            let newDefaultImport = node.name;
+            if (!resolver.isReferencedAliasDeclaration(node)) {
+                newDefaultImport = undefined;
+            }
+            const newNamedBindings = visitNode(node.namedBindings, visitor, isNamedImportBindings, /*optional*/ true);
+            return newDefaultImport !== node.name || newNamedBindings !== node.namedBindings
+                ? createImportClause(newDefaultImport, newNamedBindings)
+                : node; 
+        }
+
+        function visitNamedBindings(node: NamedImportBindings): VisitResult<NamedImportBindings> {
+            if (node.kind === SyntaxKind.NamespaceImport) {
+                return resolver.isReferencedAliasDeclaration(node) ? node: undefined;
+            }
+            else {
+                const newNamedImportElements = visitNodes((<NamedImports>node).elements, visitor, isImportSpecifier);
+                if (!newNamedImportElements || newNamedImportElements.length == 0) {
+                    return undefined;
+                }
+                if (newNamedImportElements === (<NamedImports>node).elements) {
+                    return node;
+                }
+                return createNamedImports(newNamedImportElements);
+            }
+        }
+
+        function visitImportSpecifier(node: ImportSpecifier) {
+            return resolver.isReferencedAliasDeclaration(node) ? node : undefined;
+        }
     }
 }
\ No newline at end of file