diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 2cac77bf576..383b92b7074 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -1,4 +1,4 @@
-/// <reference path="moduleNameResolver.ts"/>
+/// <reference path="moduleNameResolver.ts"/>
 /// <reference path="binder.ts"/>
 
 /* @internal */
@@ -15722,12 +15722,12 @@ namespace ts {
             }
         }
 
-        /** 
+        /**
          * Static members being set on a constructor function may conflict with built-in properties
-         * of Function. Esp. in ECMAScript 5 there are non-configurable and non-writable 
-         * built-in properties. This check issues a transpile error when a class has a static 
+         * of Function. Esp. in ECMAScript 5 there are non-configurable and non-writable
+         * built-in properties. This check issues a transpile error when a class has a static
          * member with the same name as a non-writable built-in property.
-         * 
+         *
          * @see http://www.ecma-international.org/ecma-262/5.1/#sec-15.3.3
          * @see http://www.ecma-international.org/ecma-262/5.1/#sec-15.3.5
          * @see http://www.ecma-international.org/ecma-262/6.0/#sec-properties-of-the-function-constructor
@@ -18340,7 +18340,7 @@ namespace ts {
 
             // Only check for reserved static identifiers on non-ambient context.
             if (!isInAmbientContext(node)) {
-            checkClassForStaticPropertyNameConflicts(node);
+                checkClassForStaticPropertyNameConflicts(node);
             }
 
             const baseTypeNode = getClassExtendsHeritageClauseElement(node);
diff --git a/tests/baselines/reference/staticPropertyNameConflictsInAmbientContext.symbols b/tests/baselines/reference/staticPropertyNameConflictsInAmbientContext.symbols
new file mode 100644
index 00000000000..46297eab86a
--- /dev/null
+++ b/tests/baselines/reference/staticPropertyNameConflictsInAmbientContext.symbols
@@ -0,0 +1,107 @@
+=== tests/cases/conformance/classes/propertyMemberDeclarations/decl.d.ts ===
+
+// name
+declare class StaticName {
+>StaticName : Symbol(StaticName, Decl(decl.d.ts, 0, 0))
+
+    static name: number; // ok
+>name : Symbol(StaticName.name, Decl(decl.d.ts, 2, 26))
+
+    name: string; // ok
+>name : Symbol(StaticName.name, Decl(decl.d.ts, 3, 24))
+}
+
+declare class StaticNameFn {
+>StaticNameFn : Symbol(StaticNameFn, Decl(decl.d.ts, 5, 1))
+
+    static name(): string; // ok
+>name : Symbol(StaticNameFn.name, Decl(decl.d.ts, 7, 28))
+
+    name(): string; // ok
+>name : Symbol(StaticNameFn.name, Decl(decl.d.ts, 8, 26))
+}
+
+// length
+declare class StaticLength {
+>StaticLength : Symbol(StaticLength, Decl(decl.d.ts, 10, 1))
+
+    static length: number; // ok
+>length : Symbol(StaticLength.length, Decl(decl.d.ts, 13, 28))
+
+    length: string; // ok
+>length : Symbol(StaticLength.length, Decl(decl.d.ts, 14, 26))
+}
+
+declare class StaticLengthFn {
+>StaticLengthFn : Symbol(StaticLengthFn, Decl(decl.d.ts, 16, 1))
+
+    static length(): number; // ok
+>length : Symbol(StaticLengthFn.length, Decl(decl.d.ts, 18, 30))
+
+    length(): number; // ok
+>length : Symbol(StaticLengthFn.length, Decl(decl.d.ts, 19, 28))
+}
+
+// prototype
+declare class StaticPrototype {
+>StaticPrototype : Symbol(StaticPrototype, Decl(decl.d.ts, 21, 1))
+
+    static prototype: number; // ok
+>prototype : Symbol(StaticPrototype.prototype, Decl(decl.d.ts, 24, 31))
+
+    prototype: string; // ok
+>prototype : Symbol(StaticPrototype.prototype, Decl(decl.d.ts, 25, 29))
+}
+
+declare class StaticPrototypeFn {
+>StaticPrototypeFn : Symbol(StaticPrototypeFn, Decl(decl.d.ts, 27, 1))
+
+    static prototype: any; // ok
+>prototype : Symbol(StaticPrototypeFn.prototype, Decl(decl.d.ts, 29, 33))
+
+    prototype(): any; // ok
+>prototype : Symbol(StaticPrototypeFn.prototype, Decl(decl.d.ts, 30, 26))
+}
+
+// caller
+declare class StaticCaller {
+>StaticCaller : Symbol(StaticCaller, Decl(decl.d.ts, 32, 1))
+
+    static caller: number; // ok
+>caller : Symbol(StaticCaller.caller, Decl(decl.d.ts, 35, 28))
+
+    caller: string; // ok
+>caller : Symbol(StaticCaller.caller, Decl(decl.d.ts, 36, 26))
+}
+
+declare class StaticCallerFn {
+>StaticCallerFn : Symbol(StaticCallerFn, Decl(decl.d.ts, 38, 1))
+
+    static caller(): any; // ok
+>caller : Symbol(StaticCallerFn.caller, Decl(decl.d.ts, 40, 30))
+
+    caller(): any; // ok
+>caller : Symbol(StaticCallerFn.caller, Decl(decl.d.ts, 41, 25))
+}
+
+// arguments
+declare class StaticArguments {
+>StaticArguments : Symbol(StaticArguments, Decl(decl.d.ts, 43, 1))
+
+    static arguments: number; // ok
+>arguments : Symbol(StaticArguments.arguments, Decl(decl.d.ts, 46, 31))
+
+    arguments: string; // ok
+>arguments : Symbol(StaticArguments.arguments, Decl(decl.d.ts, 47, 29))
+}
+
+declare class StaticArgumentsFn {
+>StaticArgumentsFn : Symbol(StaticArgumentsFn, Decl(decl.d.ts, 49, 1))
+
+    static arguments(): any; // ok
+>arguments : Symbol(StaticArgumentsFn.arguments, Decl(decl.d.ts, 51, 33))
+
+    arguments(): any; // ok
+>arguments : Symbol(StaticArgumentsFn.arguments, Decl(decl.d.ts, 52, 28))
+}
+