Merge branch 'master' into master-refactorJsDocTest

Kanchalai Tanglertsampan · Kanchalai Tanglertsampan · commit d7c33713e470 · 2017-05-30T08:38:08.000-07:00
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
@@ -6855,6 +6855,7 @@ namespace ts {
                     case "Object":
                         return anyType;
                     case "Function":
+                    case "function":
                         return globalFunctionType;
                     case "Array":
                     case "array":
diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts
@@ -6075,7 +6075,10 @@ namespace ts {
                     case SyntaxKind.OpenBraceToken:
                         return parseJSDocRecordType();
                     case SyntaxKind.FunctionKeyword:
-                        return parseJSDocFunctionType();
+                        if (lookAhead(nextTokenIsOpenParen)) {
+                            return parseJSDocFunctionType();
+                        }
+                        break;
                     case SyntaxKind.DotDotDotToken:
                         return parseJSDocVariadicType();
                     case SyntaxKind.NewKeyword:
@@ -6091,7 +6094,6 @@ namespace ts {
                     case SyntaxKind.NullKeyword:
                     case SyntaxKind.UndefinedKeyword:
                     case SyntaxKind.NeverKeyword:
-                    case SyntaxKind.ObjectKeyword:
                         return parseTokenNode<JSDocType>();
                     case SyntaxKind.StringLiteral:
                     case SyntaxKind.NumericLiteral:
@@ -6769,7 +6771,7 @@ namespace ts {
                             const jsDocTypeReference = <JSDocTypeReference>typeExpression.type;
                             if (jsDocTypeReference.name.kind === SyntaxKind.Identifier) {
                                 const name = <Identifier>jsDocTypeReference.name;
-                                if (name.text === "Object") {
+                                if (name.text === "Object" || name.text === "object") {
                                     typedefTag.jsDocTypeLiteral = scanChildTags();
                                 }
                             }
diff --git a/tests/baselines/reference/checkJsdocTypeTag1.js b/tests/baselines/reference/checkJsdocTypeTag1.js
@@ -18,6 +18,10 @@ anyT1 = "hi";
 const x = (a) => a + 1;
 x(1);
 
+/** @type {function} */
+const y = (a) => a + 1;
+x(1);
+
 /** @type {function (number)} */
 const x1 = (a) => a + 1;
 x1(0);
@@ -41,6 +45,9 @@ anyT1 = "hi";
 /** @type {Function} */
 var x = function (a) { return a + 1; };
 x(1);
+/** @type {function} */
+var y = function (a) { return a + 1; };
+x(1);
 /** @type {function (number)} */
 var x1 = function (a) { return a + 1; };
 x1(0);
diff --git a/tests/baselines/reference/checkJsdocTypeTag1.types b/tests/baselines/reference/checkJsdocTypeTag1.types
@@ -44,6 +44,20 @@ x(1);
 >x : Function
 >1 : 1
 
+/** @type {function} */
+const y = (a) => a + 1;
+>y : Function
+>(a) => a + 1 : (a: any) => any
+>a : any
+>a + 1 : any
+>a : any
+>1 : 1
+
+x(1);
+>x(1) : any
+>x : Function
+>1 : 1
+
 /** @type {function (number)} */
 const x1 = (a) => a + 1;
 >x1 : (arg0: number) => any
diff --git a/tests/baselines/reference/checkJsdocTypedefInParamTag1.js b/tests/baselines/reference/checkJsdocTypedefInParamTag1.js
@@ -6,12 +6,29 @@
  * @property {string=} y
  * @property {string} [z]
  * @property {string} [w="hi"]
- * 
+ *
  * @param {Opts} opts
  */
-function foo(opts) {}
+function foo(opts) {
+    opts.x;
+}
 
-foo({x: 'abc'});
+foo({x: 'abc'});
+
+/**
+ * @typedef {object} Opts1
+ * @property {string} x
+ * @property {string=} y
+ * @property {string} [z]
+ * @property {string} [w="hi"]
+ *
+ * @param {Opts1} opts
+ */
+function foo1(opts) {
+    opts.x;
+}
+foo1({x: 'abc'});
+
 
 //// [0.js]
 // @ts-check
@@ -24,5 +41,20 @@ foo({x: 'abc'});
  *
  * @param {Opts} opts
  */
-function foo(opts) { }
+function foo(opts) {
+    opts.x;
+}
 foo({ x: 'abc' });
+/**
+ * @typedef {object} Opts1
+ * @property {string} x
+ * @property {string=} y
+ * @property {string} [z]
+ * @property {string} [w="hi"]
+ *
+ * @param {Opts1} opts
+ */
+function foo1(opts) {
+    opts.x;
+}
+foo1({ x: 'abc' });
diff --git a/tests/baselines/reference/checkJsdocTypedefInParamTag1.symbols b/tests/baselines/reference/checkJsdocTypedefInParamTag1.symbols
@@ -6,14 +6,42 @@
  * @property {string=} y
  * @property {string} [z]
  * @property {string} [w="hi"]
- * 
+ *
  * @param {Opts} opts
  */
-function foo(opts) {}
+function foo(opts) {
 >foo : Symbol(foo, Decl(0.js, 0, 0))
 >opts : Symbol(opts, Decl(0.js, 10, 13))
 
+    opts.x;
+>opts.x : Symbol(x, Decl(0.js, 3, 3))
+>opts : Symbol(opts, Decl(0.js, 10, 13))
+>x : Symbol(x, Decl(0.js, 3, 3))
+}
+
 foo({x: 'abc'});
 >foo : Symbol(foo, Decl(0.js, 0, 0))
->x : Symbol(x, Decl(0.js, 12, 5))
+>x : Symbol(x, Decl(0.js, 14, 5))
+
+/**
+ * @typedef {object} Opts1
+ * @property {string} x
+ * @property {string=} y
+ * @property {string} [z]
+ * @property {string} [w="hi"]
+ *
+ * @param {Opts1} opts
+ */
+function foo1(opts) {
+>foo1 : Symbol(foo1, Decl(0.js, 14, 16))
+>opts : Symbol(opts, Decl(0.js, 25, 14))
+
+    opts.x;
+>opts.x : Symbol(x, Decl(0.js, 18, 3))
+>opts : Symbol(opts, Decl(0.js, 25, 14))
+>x : Symbol(x, Decl(0.js, 18, 3))
+}
+foo1({x: 'abc'});
+>foo1 : Symbol(foo1, Decl(0.js, 14, 16))
+>x : Symbol(x, Decl(0.js, 28, 6))
 
diff --git a/tests/baselines/reference/checkJsdocTypedefInParamTag1.types b/tests/baselines/reference/checkJsdocTypedefInParamTag1.types
@@ -6,17 +6,48 @@
  * @property {string=} y
  * @property {string} [z]
  * @property {string} [w="hi"]
- * 
+ *
  * @param {Opts} opts
  */
-function foo(opts) {}
+function foo(opts) {
 >foo : (opts: { x: string; y?: string; z?: string; w?: string; }) => void
 >opts : { x: string; y?: string; z?: string; w?: string; }
 
+    opts.x;
+>opts.x : string
+>opts : { x: string; y?: string; z?: string; w?: string; }
+>x : string
+}
+
 foo({x: 'abc'});
 >foo({x: 'abc'}) : void
 >foo : (opts: { x: string; y?: string; z?: string; w?: string; }) => void
 >{x: 'abc'} : { x: string; }
 >x : string
 >'abc' : "abc"
 
+/**
+ * @typedef {object} Opts1
+ * @property {string} x
+ * @property {string=} y
+ * @property {string} [z]
+ * @property {string} [w="hi"]
+ *
+ * @param {Opts1} opts
+ */
+function foo1(opts) {
+>foo1 : (opts: { x: string; y?: string; z?: string; w?: string; }) => void
+>opts : { x: string; y?: string; z?: string; w?: string; }
+
+    opts.x;
+>opts.x : string
+>opts : { x: string; y?: string; z?: string; w?: string; }
+>x : string
+}
+foo1({x: 'abc'});
+>foo1({x: 'abc'}) : void
+>foo1 : (opts: { x: string; y?: string; z?: string; w?: string; }) => void
+>{x: 'abc'} : { x: string; }
+>x : string
+>'abc' : "abc"
+
diff --git a/tests/baselines/reference/jsDocTypeTag2.js b/tests/baselines/reference/jsDocTypeTag2.js
@@ -431,28 +431,8 @@
           "kind": "space"
         },
         {
-          "text": "(",
-          "kind": "punctuation"
-        },
-        {
-          "text": ")",
-          "kind": "punctuation"
-        },
-        {
-          "text": " ",
-          "kind": "space"
-        },
-        {
-          "text": "=>",
-          "kind": "punctuation"
-        },
-        {
-          "text": " ",
-          "kind": "space"
-        },
-        {
-          "text": "any",
-          "kind": "keyword"
+          "text": "Function",
+          "kind": "localName"
         }
       ],
       "documentation": [],
diff --git a/tests/baselines/reference/jsDocTypedef1.js b/tests/baselines/reference/jsDocTypedef1.js
diff --git a/tests/cases/conformance/jsdoc/checkJsdocTypeTag1.ts b/tests/cases/conformance/jsdoc/checkJsdocTypeTag1.ts
diff --git a/tests/cases/conformance/jsdoc/checkJsdocTypedefInParamTag1.ts b/tests/cases/conformance/jsdoc/checkJsdocTypedefInParamTag1.ts
diff --git a/tests/cases/fourslash/jsDocTypedefQuickInfo1.ts b/tests/cases/fourslash/jsDocTypedefQuickInfo1.ts
