diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 056879f099a..dba1dab5d7c 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -43,10 +43,9 @@ module ts {
 
         var globals: SymbolTable = {};
 
-        var globalArrayTypeSymbolLinks: SymbolLinks;
-
         var globalObjectType: ObjectType;
         var globalFunctionType: ObjectType;
+        var globalArrayType: ObjectType;
         var globalStringType: ObjectType;
         var globalNumberType: ObjectType;
         var globalBooleanType: ObjectType;
@@ -774,7 +773,7 @@ module ts {
             }
 
             function writeTypeReference(type: TypeReference) {
-                if (type.target === globalArrayTypeSymbolLinks.declaredType && !(flags & TypeFormatFlags.WriteArrayAsGenericType)) {
+                if (type.target === globalArrayType && !(flags & TypeFormatFlags.WriteArrayAsGenericType)) {
                     // If we are writing array element type the arrow style signatures are not allowed as 
                     // we need to surround it by curlies, eg. { (): T; }[]; as () => T[] would mean something different
                     writeType(type.typeArguments[0], /*allowFunctionOrConstructorTypeLiteral*/ false);
@@ -1806,7 +1805,7 @@ module ts {
         function getRestTypeOfSignature(signature: Signature): Type {
             if (signature.hasRestParameter) {
                 var type = getTypeOfSymbol(signature.parameters[signature.parameters.length - 1]);
-                if (type.flags & TypeFlags.Reference && (<TypeReference>type).target === globalArrayTypeSymbolLinks.declaredType) {
+                if (type.flags & TypeFlags.Reference && (<TypeReference>type).target === globalArrayType) {
                     return (<TypeReference>type).typeArguments[0];
                 }
             }
@@ -2017,11 +2016,8 @@ module ts {
             return links.resolvedType;
         }
 
-        function resolveGlobalTypeSymbol(name: string): Symbol {
-            return resolveName(undefined, name, SymbolFlags.Type, Diagnostics.Cannot_find_global_type_0, name);
-        }
+        function getGlobalType(name: string, arity: number = 0): ObjectType {
 
-        function resolveGlobalType(symbol: Symbol, arity: number): ObjectType {
             function getTypeDeclaration(symbol: Symbol): Declaration {
                 var declarations = symbol.declarations;
                 for (var i = 0; i < declarations.length; i++) {
@@ -2036,6 +2032,8 @@ module ts {
                     }
                 }
             }
+
+            var symbol = resolveName(undefined, name, SymbolFlags.Type, Diagnostics.Cannot_find_global_type_0, name);
             if (!symbol) {
                 return emptyObjectType;
             }
@@ -2051,19 +2049,22 @@ module ts {
             return <ObjectType>type;
         }
 
-        function getGlobalType(name: string, arity: number = 0): ObjectType {
-            return resolveGlobalType(resolveGlobalTypeSymbol(name), arity);
-        }
-
-        function createArrayType(elementType: Type): Type {
-            var globalArrayType = globalArrayTypeSymbolLinks.declaredType;
-            return globalArrayType !== emptyObjectType ? createTypeReference(<GenericType>globalArrayType, [elementType]) : emptyObjectType;
+        function createArrayType(elementType: Type, arrayType?: ObjectType): Type {
+            var type = globalArrayType || arrayType;
+            return type !== emptyObjectType ? createTypeReference(<GenericType>type, [elementType]) : emptyObjectType;
         }
 
         function getTypeFromArrayTypeNode(node: ArrayTypeNode): Type {
             var links = getNodeLinks(node);
             if (!links.resolvedType) {
-                links.resolvedType = createArrayType(getTypeFromTypeNode(node.elementType));
+                var arrayType = globalArrayType;
+                if (!arrayType) {
+                    var arrayTypeSymbol = resolveName(node, "Array", SymbolFlags.Type, /*nameNotFoundMessage*/ undefined, /*nameArg*/ undefined);
+                    Debug.assert(arrayTypeSymbol);
+                    arrayType = getDeclaredTypeOfSymbol(arrayTypeSymbol);
+                    Debug.assert(arrayType);
+                }
+                links.resolvedType = createArrayType(getTypeFromTypeNode(node.elementType), arrayType);
             }
             return links.resolvedType;
         }
@@ -2951,7 +2952,7 @@ module ts {
         }
 
         function isArrayType(type: Type): boolean {
-            return type.flags & TypeFlags.Reference && (<TypeReference>type).target === globalArrayTypeSymbolLinks.declaredType;
+            return type.flags & TypeFlags.Reference && (<TypeReference>type).target === globalArrayType;
         }
 
         function getInnermostTypeOfNestedArrayTypes(type: Type): Type {
@@ -6289,22 +6290,7 @@ module ts {
             getSymbolLinks(unknownSymbol).type = unknownType;
             globals[undefinedSymbol.name] = undefinedSymbol;
             // Initialize special types
-            // Initialize array type. 
-            // Note:
-            // if user code extends Array type so extension contains signatures that involve arrays (sample below)
-            // then just calling getGlobalType(Array) will try to access globalArrayType before it is initialized
-            // to handle this instead of storing Array as type we store SymbolLinks for Array symbol and access type as links.declaredType.
-            // interface Array<T> { (): any[] }
-            // 
-            var globalArraySymbol = resolveGlobalTypeSymbol("Array");
-            if (!globalArraySymbol) {
-                globalArrayTypeSymbolLinks = { declaredType: emptyObjectType };
-            }
-            else {
-                globalArrayTypeSymbolLinks = getSymbolLinks(globalArraySymbol);
-                globalArrayTypeSymbolLinks.declaredType = resolveGlobalType(globalArraySymbol, 1);
-            }
-
+            globalArrayType = getGlobalType("Array", 1);
             globalObjectType = getGlobalType("Object");
             globalFunctionType = getGlobalType("Function");
             globalStringType = getGlobalType("String");