Emit 'object' type in declaration emitter

src/compiler/declarationEmitter.ts

@@ -390,6 +390,7 @@ namespace ts {
                 case SyntaxKind.StringKeyword:
                 case SyntaxKind.NumberKeyword:
                 case SyntaxKind.BooleanKeyword:
+                case SyntaxKind.ObjectKeyword:
                 case SyntaxKind.SymbolKeyword:
                 case SyntaxKind.VoidKeyword:
                 case SyntaxKind.UndefinedKeyword:

tests/baselines/reference/nonPrimitiveAsProperty.js

@@ -11,3 +11,11 @@ var b: WithNonPrimitive = {foo: "bar"}; // expect error
 //// [nonPrimitiveAsProperty.js]
 var a = { foo: { bar: "bar" } };
 var b = { foo: "bar" }; // expect error
+
+
+//// [nonPrimitiveAsProperty.d.ts]
+interface WithNonPrimitive {
+    foo: object;
+}
+declare var a: WithNonPrimitive;
+declare var b: WithNonPrimitive;

tests/baselines/reference/nonPrimitiveInFunction.js

@@ -34,3 +34,11 @@ function returnError() {
     var ret = 123;
     return ret; // expect error
 }
+
+
+//// [nonPrimitiveInFunction.d.ts]
+declare function takeObject(o: object): void;
+declare function returnObject(): object;
+declare var nonPrimitive: object;
+declare var primitive: boolean;
+declare function returnError(): object;

tests/baselines/reference/nonPrimitiveInGeneric.js

@@ -73,3 +73,21 @@ var x; // error
 var y; // ok
 var z; // ok
 var u; // ok
+
+
+//// [nonPrimitiveInGeneric.d.ts]
+declare function generic<T>(t: T): void;
+declare var a: {};
+declare var b: string;
+declare function bound<T extends object>(t: T): void;
+declare function bound2<T extends object>(): void;
+declare function bound3<T extends {}>(t: T): void;
+interface Proxy<T extends object> {
+}
+declare var x: Proxy<number>;
+declare var y: Proxy<null>;
+declare var z: Proxy<undefined>;
+interface Blah {
+    foo: number;
+}
+declare var u: Proxy<Blah>;

tests/baselines/reference/nonPrimitiveUnionIntersection.js

@@ -10,3 +10,8 @@ var a = ""; // error
 var b = ""; // ok
 a = b; // error
 b = a; // ok
+
+
+//// [nonPrimitiveUnionIntersection.d.ts]
+declare var a: object & string;
+declare var b: object | string;

tests/cases/conformance/types/nonPrimitive/nonPrimitiveAsProperty.ts

@@ -1,3 +1,4 @@
+// @declaration: true
 interface WithNonPrimitive {
     foo: object
 }

tests/cases/conformance/types/nonPrimitive/nonPrimitiveInFunction.ts

@@ -1,3 +1,4 @@
+// @declaration: true
 function takeObject(o: object) {}
 function returnObject(): object {
     return {};

tests/cases/conformance/types/nonPrimitive/nonPrimitiveInGeneric.ts

@@ -1,3 +1,4 @@
+// @declaration: true
 function generic<T>(t: T) {
     var o: object = t; // expect error
 }

tests/cases/conformance/types/nonPrimitive/nonPrimitiveUnionIntersection.ts

@@ -1,3 +1,4 @@
+// @declaration: true
 var a: object & string = ""; // error
 var b: object | string = ""; // ok
 a = b; // error