diff --git a/src/compiler/factory.ts b/src/compiler/factory.ts
index 88bf5f458f..14af23e95b 100644
--- a/src/compiler/factory.ts
+++ b/src/compiler/factory.ts
@@ -189,11 +189,11 @@ namespace ts {
     }
 
     export function createTrue() {
-        return <BooleanLiteral>createSynthesizedNode(SyntaxKind.TrueKeyword);
+        return <BooleanLiteral & TypeNode>createSynthesizedNode(SyntaxKind.TrueKeyword);
     }
 
     export function createFalse() {
-        return <BooleanLiteral>createSynthesizedNode(SyntaxKind.FalseKeyword);
+        return <BooleanLiteral & TypeNode>createSynthesizedNode(SyntaxKind.FalseKeyword);
     }
 
     // Names
@@ -226,15 +226,6 @@ namespace ts {
 
     // Type Elements
 
-    export function createPropertySignature(name: PropertyName, questionToken?: QuestionToken, type?: TypeNode, initializer?: Expression): PropertySignature {
-        const propertySignature = createSynthesizedNode(SyntaxKind.PropertySignature) as PropertySignature;
-        propertySignature.name = name;
-        propertySignature.questionToken = questionToken;
-        propertySignature.type = type;
-        propertySignature.initializer = initializer;
-        return propertySignature;
-    }
-
     export function createConstructSignature() {
         throw new Error("not implemented.");
     }
@@ -258,14 +249,26 @@ namespace ts {
     }
 
     // TODO: handle qualified names, ie EntityName's.
-    export function createTypeReferenceNode(typeName: string | Identifier, typeArguments?: NodeArray<TypeNode>) {
+    export function createTypeReferenceNode(typeName: string | EntityName, typeArguments?: NodeArray<TypeNode>) {
         const typeReference = createSynthesizedNode(SyntaxKind.TypeReference) as TypeReferenceNode;
-        typeReference.typeName = asName(typeName);
+        
+        typeReference.typeName = isQualifiedName(<EntityName>typeName) ? <QualifiedName>typeName : asName(<string | Identifier>typeName);
         typeReference.typeArguments = typeArguments;
         return typeReference;
     }
 
-    export function updateTypeReferenceNode(node: TypeReferenceNode, typeName: Identifier, typeArguments?: NodeArray<TypeNode>) {
+    export function createArrayTypeNode(elementType: TypeNode): ArrayTypeNode {
+        const arrayTypeNode = createSynthesizedNode(SyntaxKind.ArrayType) as ArrayTypeNode;
+        arrayTypeNode.elementType = elementType;
+        return arrayTypeNode;
+    }
+    
+    export function updateArrayTypeNode(node: ArrayTypeNode, elementType: TypeNode): ArrayTypeNode {
+        return node.elementType !== elementType
+             ? updateNode(createArrayTypeNode(elementType), node)
+             : node;
+    }
+    export function updateTypeReferenceNode(node: TypeReferenceNode, typeName: EntityName, typeArguments?: NodeArray<TypeNode>) {
         return node.typeName !== typeName
             || node.typeArguments !== typeArguments
             ? updateNode(createTypeReferenceNode(typeName, typeArguments), node)
@@ -288,7 +291,7 @@ namespace ts {
     }
 
     export function createTypeLiteralNode(members: TypeElement[]) {
-        const typeLiteralNode = createSynthesizedNode(SyntaxKind.LiteralType) as TypeLiteralNode;
+        const typeLiteralNode = createSynthesizedNode(SyntaxKind.TypeLiteral) as TypeLiteralNode;
         typeLiteralNode.members = asNodeArray(members);
         return typeLiteralNode;
     }
@@ -332,7 +335,24 @@ namespace ts {
 
     // Signature elements
 
-    /** Note, can also be used to construct index signatures. */
+    export function createPropertySignature(name: PropertyName, questionToken?: QuestionToken, type?: TypeNode, initializer?: Expression): PropertySignature {
+        const propertySignature = createSynthesizedNode(SyntaxKind.PropertySignature) as PropertySignature;
+        propertySignature.name = name;
+        propertySignature.questionToken = questionToken;
+        propertySignature.type = type;
+        propertySignature.initializer = initializer;
+        return propertySignature;
+    }
+
+    export function updatePropertySignature(node: PropertySignature, name: PropertyName, questionToken?: QuestionToken, type?: TypeNode, initializer?: Expression) {
+        return node.name !== name
+            || node.questionToken !== questionToken
+            || node.type !== type
+            || node.initializer !== initializer
+            ? updateNode(createPropertySignature(name, questionToken, type, initializer), node)
+            : node;
+    }
+
     export function createSignature(kind: SyntaxKind, parameters: NodeArray<ParameterDeclaration>, name?: PropertyName, typeParameters?: NodeArray<TypeParameterDeclaration>, returnType?: TypeNode): SignatureDeclaration {
         const signature = createSynthesizedNode(kind) as SignatureDeclaration;
         signature.parameters = parameters;
diff --git a/src/compiler/visitor.ts b/src/compiler/visitor.ts
index d2991b7cf0..547178e3b7 100644
--- a/src/compiler/visitor.ts
+++ b/src/compiler/visitor.ts
@@ -279,7 +279,7 @@ namespace ts {
                 return updateDecorator(<Decorator>node,
                     visitNode((<Decorator>node).expression, visitor, isExpression));
 
-            // Keyword Types
+            // Keyword Types and This
 
             case SyntaxKind.AnyKeyword:
             case SyntaxKind.NumberKeyword:
@@ -292,6 +292,7 @@ namespace ts {
             case SyntaxKind.NullKeyword:
             case SyntaxKind.NeverKeyword:
             case SyntaxKind.NeverKeyword:
+            case SyntaxKind.ThisKeyword:
                 return node;
 
             // Types
@@ -300,8 +301,8 @@ namespace ts {
                 throw new Error("reached unsupported type in visitor.");
             case SyntaxKind.TypeReference:
                 return updateTypeReferenceNode(<TypeReferenceNode>node
-                     , visitNode((<TypeReferenceNode>node).typeName as Identifier, visitor)
-                     , nodesVisitor((<TypeReferenceNode>node).typeArguments, visitor)
+                     , visitNode((<TypeReferenceNode>node).typeName, visitor, isEntityName)
+                     , nodesVisitor((<TypeReferenceNode>node).typeArguments, visitor, isTypeNode)
                 );
             case SyntaxKind.FunctionType:
                 throw new Error("reached unsupported type in visitor.");
@@ -310,9 +311,9 @@ namespace ts {
             case SyntaxKind.TypeQuery:
                 throw new Error("reached unsupported type in visitor.");
             case SyntaxKind.TypeLiteral:
-                throw new Error("reached unsupported type in visitor.");
+                return updateTypeLiteralNode((<TypeLiteralNode>node), nodesVisitor((<TypeLiteralNode>node).members, visitor));
             case SyntaxKind.ArrayType:
-                throw new Error("reached unsupported type in visitor.");
+                return updateArrayTypeNode(<ArrayTypeNode>node, visitNode((<ArrayTypeNode>node).elementType, visitor, isTypeNode));
             case SyntaxKind.TupleType:
                 throw new Error("reached unsupported type in visitor.");
             case SyntaxKind.UnionType:
@@ -342,8 +343,14 @@ namespace ts {
 
             // Type members
 
+            case SyntaxKind.PropertySignature:
+                return updatePropertySignature((<PropertySignature>node)
+                    , visitNode((<PropertySignature>node).name, visitor, isPropertyName)
+                    , visitNode((<PropertySignature>node).questionToken, visitor, isToken)
+                    , visitNode((<PropertySignature>node).type, visitor, isTypeNode));
+
             case SyntaxKind.IndexSignature:
-                updateIndexSignatureDeclaration(<IndexSignatureDeclaration>node
+                return updateIndexSignatureDeclaration(<IndexSignatureDeclaration>node
                     , nodesVisitor((<IndexSignatureDeclaration>node).parameters, visitor, isParameter)
                     , visitNode((<IndexSignatureDeclaration>node).type, visitor, isTypeNode)
                     , nodesVisitor((<IndexSignatureDeclaration>node).decorators, visitor, isDecorator)