From 496042cf7952a9931c73095dda9a8543668c1b7a Mon Sep 17 00:00:00 2001
From: yoyo930021 <yoyo930021@gmail.com>
Date: Fri, 7 Jun 2019 23:45:28 +0800
Subject: [PATCH 01/14] Add support analyzing vue-class-component and
 vue-property-decorator

---
 server/src/modes/script/childComponents.ts |  52 +--
 server/src/modes/script/componentInfo.ts   | 362 +++++++++++++++------
 2 files changed, 296 insertions(+), 118 deletions(-)

diff --git a/server/src/modes/script/childComponents.ts b/server/src/modes/script/childComponents.ts
index 99a7fa7c80..026293d275 100644
--- a/server/src/modes/script/childComponents.ts
+++ b/server/src/modes/script/childComponents.ts
@@ -1,5 +1,5 @@
 import * as ts from 'typescript';
-import { getLastChild, buildDocumentation, getDefaultExportObjectLiteralExpr } from './componentInfo';
+import { getLastChild, buildDocumentation, getDefaultExportNode } from './componentInfo';
 import { T_TypeScript } from '../../services/dependencyService';
 
 interface InternalChildComponent {
@@ -10,7 +10,7 @@ interface InternalChildComponent {
     start: number;
     end: number;
   };
-  defaultExportExpr?: ts.Node;
+  defaultExportNode?: ts.Node;
 }
 
 export function getChildComponents(
@@ -19,7 +19,15 @@ export function getChildComponents(
   checker: ts.TypeChecker,
   tagCasing = 'kebab'
 ): InternalChildComponent[] | undefined {
-  const componentsSymbol = checker.getPropertyOfType(defaultExportType, 'components');
+  let type = defaultExportType;
+  if (defaultExportType.isClass()) {
+    // get decorator argument type when class
+    type = checker.getTypeAtLocation(
+      (defaultExportType.symbol.declarations[0].decorators![0].expression as ts.CallExpression).arguments[0]
+    );
+  }
+
+  const componentsSymbol = checker.getPropertyOfType(type, 'components');
   if (!componentsSymbol || !componentsSymbol.valueDeclaration) {
     return undefined;
   }
@@ -56,27 +64,25 @@ export function getChildComponents(
       }
 
       if (objectLiteralSymbol.flags & tsModule.SymbolFlags.Alias) {
-        const definitionObjectLiteralSymbol = checker.getAliasedSymbol(objectLiteralSymbol);
-        if (definitionObjectLiteralSymbol.valueDeclaration) {
-          const defaultExportExpr = getDefaultExportObjectLiteralExpr(
-            tsModule,
-            definitionObjectLiteralSymbol.valueDeclaration.getSourceFile()
-          );
-          if (!defaultExportExpr) {
-            return;
-          }
-
-          result.push({
-            name: componentName,
-            documentation: buildDocumentation(tsModule, definitionObjectLiteralSymbol, checker),
-            definition: {
-              path: definitionObjectLiteralSymbol.valueDeclaration.getSourceFile().fileName,
-              start: defaultExportExpr.getStart(undefined, true),
-              end: defaultExportExpr.getEnd()
-            },
-            defaultExportExpr
-          });
+        const definitionSymbol = checker.getAliasedSymbol(objectLiteralSymbol);
+        const sourceFile = definitionSymbol.valueDeclaration.getSourceFile()
+        const defaultExportNode = getDefaultExportNode(
+          tsModule,
+          sourceFile
+        );
+        if (!defaultExportNode) {
+          return;
         }
+        result.push({
+          name: componentName,
+          documentation: buildDocumentation(tsModule, definitionSymbol, checker),
+          definition: {
+            path: sourceFile.fileName,
+            start: defaultExportNode.getStart(sourceFile, true),
+            end: defaultExportNode.getEnd()
+          },
+          defaultExportNode
+        });
       }
     });
 
diff --git a/server/src/modes/script/componentInfo.ts b/server/src/modes/script/componentInfo.ts
index 78cdb7e9b3..a3b39707a6 100644
--- a/server/src/modes/script/componentInfo.ts
+++ b/server/src/modes/script/componentInfo.ts
@@ -28,14 +28,14 @@ export function getComponentInfo(
 
   const checker = program.getTypeChecker();
 
-  const defaultExportExpr = getDefaultExportObjectLiteralExpr(tsModule, sourceFile);
-  if (!defaultExportExpr) {
+  const defaultExportNode = getDefaultExportNode(tsModule, sourceFile);
+  if (!defaultExportNode) {
     return undefined;
   }
 
-  const vueFileInfo = analyzeDefaultExportExpr(tsModule, defaultExportExpr, checker);
+  const vueFileInfo = analyzeDefaultExportExpr(tsModule, defaultExportNode, checker);
 
-  const defaultExportType = checker.getTypeAtLocation(defaultExportExpr);
+  const defaultExportType = checker.getTypeAtLocation(defaultExportNode);
   const internalChildComponents = getChildComponents(
     tsModule,
     defaultExportType,
@@ -50,7 +50,7 @@ export function getComponentInfo(
         name: c.name,
         documentation: c.documentation,
         definition: c.definition,
-        info: c.defaultExportExpr ? analyzeDefaultExportExpr(tsModule, c.defaultExportExpr, checker) : undefined
+        info: c.defaultExportNode ? analyzeDefaultExportExpr(tsModule, c.defaultExportNode, checker) : undefined
       });
     });
     vueFileInfo.componentInfo.childComponents = childComponents;
@@ -61,10 +61,10 @@ export function getComponentInfo(
 
 export function analyzeDefaultExportExpr(
   tsModule: T_TypeScript,
-  defaultExportExpr: ts.Node,
+  defaultExport: ts.Node,
   checker: ts.TypeChecker
 ): VueFileInfo {
-  const defaultExportType = checker.getTypeAtLocation(defaultExportExpr);
+  const defaultExportType = checker.getTypeAtLocation(defaultExport);
 
   const props = getProps(tsModule, defaultExportType, checker);
   const data = getData(tsModule, defaultExportType, checker);
@@ -81,66 +81,104 @@ export function analyzeDefaultExportExpr(
   };
 }
 
-export function getDefaultExportObjectLiteralExpr(
+export function getDefaultExportNode(
   tsModule: T_TypeScript,
   sourceFile: ts.SourceFile
-): ts.Expression | undefined {
-  const exportStmts = sourceFile.statements.filter(st => st.kind === tsModule.SyntaxKind.ExportAssignment);
+): ts.Node | undefined {
+  const exportStmts = sourceFile.statements.filter(st =>
+    st.kind === tsModule.SyntaxKind.ExportAssignment ||
+    st.kind === tsModule.SyntaxKind.ClassDeclaration
+  );
   if (exportStmts.length === 0) {
     return undefined;
   }
-  const exportExpr = (exportStmts[0] as ts.ExportAssignment).expression;
+  const exportNode = (exportStmts[0].kind === tsModule.SyntaxKind.ExportAssignment) ?
+    (exportStmts[0] as ts.ExportAssignment).expression : (exportStmts[0] as ts.ClassDeclaration);
 
-  return getObjectLiteralExprFromExportExpr(tsModule, exportExpr);
+  return getNodeFromExportNode(tsModule, exportNode);
 }
 
 function getProps(tsModule: T_TypeScript, defaultExportType: ts.Type, checker: ts.TypeChecker): PropInfo[] | undefined {
-  const propsSymbol = checker.getPropertyOfType(defaultExportType, 'props');
-  if (!propsSymbol || !propsSymbol.valueDeclaration) {
-    return undefined;
+  const result: PropInfo[] = [];
+  if (defaultExportType.isClass()) {
+    result.push.apply(result, getClassProps(defaultExportType) || []);
+
+    const decoratorArgumentType = checker.getTypeAtLocation(
+      (defaultExportType.symbol.declarations[0].decorators![0].expression as ts.CallExpression).arguments[0]
+    );
+    result.push.apply(result, getObjectProps(decoratorArgumentType) || []);
+  } else {
+    result.push.apply(result, getObjectProps(defaultExportType) || []);
   }
 
-  const propsDeclaration = getLastChild(propsSymbol.valueDeclaration);
-  if (!propsDeclaration) {
-    return undefined;
+  function getClassProps (type: ts.Type) {
+    const propsSymbols = type.getProperties()
+      .filter((property) =>
+        property.valueDeclaration.kind === tsModule.SyntaxKind.PropertyDeclaration &&
+        property.declarations[0].decorators &&
+        property.declarations[0].decorators.some((decorator) =>
+          (decorator.expression as ts.CallExpression).expression.getText() === 'Prop' ||
+          (decorator.expression as ts.CallExpression).expression.getText() === 'Model'
+        )
+      );
+    if (propsSymbols.length === 0) { return undefined; }
+
+    return propsSymbols.map((prop) => {
+      return {
+        name: prop.name,
+        documentation: buildDocumentation(tsModule, prop, checker)
+      };
+    });
   }
 
-  /**
-   * Plain array props like `props: ['foo', 'bar']`
-   */
-  if (propsDeclaration.kind === tsModule.SyntaxKind.ArrayLiteralExpression) {
-    return (propsDeclaration as ts.ArrayLiteralExpression).elements
-      .filter(expr => expr.kind === tsModule.SyntaxKind.StringLiteral)
-      .map(expr => {
+  function getObjectProps (type: ts.Type) {
+    const propsSymbol = checker.getPropertyOfType(type, 'props');
+    if (!propsSymbol || !propsSymbol.valueDeclaration) {
+      return undefined;
+    }
+
+    const propsDeclaration = getLastChild(propsSymbol.valueDeclaration);
+    if (!propsDeclaration) {
+      return undefined;
+    }
+
+    /**
+     * Plain array props like `props: ['foo', 'bar']`
+     */
+    if (propsDeclaration.kind === tsModule.SyntaxKind.ArrayLiteralExpression) {
+      return (propsDeclaration as ts.ArrayLiteralExpression).elements
+        .filter(expr => expr.kind === tsModule.SyntaxKind.StringLiteral)
+        .map(expr => {
+          return {
+            name: (expr as ts.StringLiteral).text
+          };
+        });
+    }
+
+    /**
+     * Object literal props like
+     * ```
+     * {
+     *   props: {
+     *     foo: { type: Boolean, default: true },
+     *     bar: { type: String, default: 'bar' }
+     *   }
+     * }
+     * ```
+     */
+    if (propsDeclaration.kind === tsModule.SyntaxKind.ObjectLiteralExpression) {
+      const propsType = checker.getTypeOfSymbolAtLocation(propsSymbol, propsDeclaration);
+
+      return checker.getPropertiesOfType(propsType).map(s => {
         return {
-          name: (expr as ts.StringLiteral).text
+          name: s.name,
+          documentation: buildDocumentation(tsModule, s, checker)
         };
       });
+    }
   }
 
-  /**
-   * Object literal props like
-   * ```
-   * {
-   *   props: {
-   *     foo: { type: Boolean, default: true },
-   *     bar: { type: String, default: 'bar' }
-   *   }
-   * }
-   * ```
-   */
-  if (propsDeclaration.kind === tsModule.SyntaxKind.ObjectLiteralExpression) {
-    const propsType = checker.getTypeOfSymbolAtLocation(propsSymbol, propsDeclaration);
-
-    return checker.getPropertiesOfType(propsType).map(s => {
-      return {
-        name: s.name,
-        documentation: buildDocumentation(tsModule, s, checker)
-      };
-    });
-  }
-
-  return undefined;
+  return result.length === 0 ? undefined : result;
 }
 
 /**
@@ -157,23 +195,64 @@ function getProps(tsModule: T_TypeScript, defaultExportType: ts.Type, checker: t
  * ```
  */
 function getData(tsModule: T_TypeScript, defaultExportType: ts.Type, checker: ts.TypeChecker): DataInfo[] | undefined {
-  const dataSymbol = checker.getPropertyOfType(defaultExportType, 'data');
-  if (!dataSymbol || !dataSymbol.valueDeclaration) {
-    return undefined;
+  const result: DataInfo[] = [];
+  if (defaultExportType.isClass()) {
+    result.push.apply(result, getClassData(defaultExportType) || []);
+
+    const decoratorArgumentType = checker.getTypeAtLocation(
+      (defaultExportType.symbol.declarations[0].decorators![0].expression as ts.CallExpression).arguments[0]
+    );
+    result.push.apply(result, getObjectData(decoratorArgumentType) || []);
+  } else {
+    result.push.apply(result, getObjectData(defaultExportType) || []);
   }
 
-  const dataType = checker.getTypeOfSymbolAtLocation(dataSymbol, dataSymbol.valueDeclaration);
-  const dataSignatures = dataType.getCallSignatures();
-  if (dataSignatures.length === 0) {
-    return undefined;
+  function getClassData (type: ts.Type) {
+    const dataSymbols = type.getProperties()
+      .filter((property) =>
+        property.valueDeclaration.kind === tsModule.SyntaxKind.PropertyDeclaration && (
+          property.declarations[0].decorators === undefined || (
+            property.declarations[0].decorators &&
+            !property.declarations[0].decorators.some((decorator) =>
+              (decorator.expression as ts.CallExpression).expression.getText() === 'Prop' ||
+              (decorator.expression as ts.CallExpression).expression.getText() === 'Model' ||
+              (decorator.expression as ts.CallExpression).expression.getText() === 'Inject'
+            )
+          )
+        ) &&
+        !property.name.startsWith('_') && !property.name.startsWith('$')
+      );
+    if (dataSymbols.length === 0) { return undefined; }
+
+    return dataSymbols.map((data) => {
+      return {
+        name: data.name,
+        documentation: buildDocumentation(tsModule, data, checker)
+      };
+    });
   }
-  const dataReturnTypeProperties = checker.getReturnTypeOfSignature(dataSignatures[0]);
-  return dataReturnTypeProperties.getProperties().map(s => {
-    return {
-      name: s.name,
-      documentation: buildDocumentation(tsModule, s, checker)
-    };
-  });
+
+  function getObjectData (type: ts.Type) {
+    const dataSymbol = checker.getPropertyOfType(type, 'data');
+    if (!dataSymbol || !dataSymbol.valueDeclaration) {
+      return undefined;
+    }
+
+    const dataType = checker.getTypeOfSymbolAtLocation(dataSymbol, dataSymbol.valueDeclaration);
+    const dataSignatures = dataType.getCallSignatures();
+    if (dataSignatures.length === 0) {
+      return undefined;
+    }
+    const dataReturnTypeProperties = checker.getReturnTypeOfSignature(dataSignatures[0]);
+    return dataReturnTypeProperties.getProperties().map(s => {
+      return {
+        name: s.name,
+        documentation: buildDocumentation(tsModule, s, checker)
+      };
+    });
+  }
+
+  return result.length === 0 ? undefined : result;
 }
 
 function getComputed(
@@ -181,28 +260,83 @@ function getComputed(
   defaultExportType: ts.Type,
   checker: ts.TypeChecker
 ): ComputedInfo[] | undefined {
-  const computedSymbol = checker.getPropertyOfType(defaultExportType, 'computed');
-  if (!computedSymbol || !computedSymbol.valueDeclaration) {
-    return undefined;
+  const result: ComputedInfo[] = [];
+  if (defaultExportType.isClass()) {
+    result.push.apply(result, getClassComputed(defaultExportType) || []);
+
+    const decoratorArgumentType = checker.getTypeAtLocation(
+      (defaultExportType.symbol.declarations[0].decorators![0].expression as ts.CallExpression).arguments[0]
+    );
+    result.push.apply(result, getObjectComputed(decoratorArgumentType) || []);
+  } else {
+    result.push.apply(result, getObjectComputed(defaultExportType) || []);
   }
 
-  const computedDeclaration = getLastChild(computedSymbol.valueDeclaration);
-  if (!computedDeclaration) {
-    return undefined;
-  }
-
-  if (computedDeclaration.kind === tsModule.SyntaxKind.ObjectLiteralExpression) {
-    const computedType = checker.getTypeOfSymbolAtLocation(computedSymbol, computedDeclaration);
-
-    return checker.getPropertiesOfType(computedType).map(s => {
+  function getClassComputed (type: ts.Type) {
+    const getAccessorSymbols = type.getProperties()
+      .filter((property) =>
+        property.valueDeclaration.kind === tsModule.SyntaxKind.GetAccessor
+      );
+    const setAccessorSymbols = defaultExportType.getProperties()
+    .filter((property) =>
+      property.valueDeclaration.kind === tsModule.SyntaxKind.SetAccessor
+    );
+    if (getAccessorSymbols.length === 0) { return undefined; }
+
+    return getAccessorSymbols.map((computed) => {
+      const setComputed = setAccessorSymbols.find((setAccessor) => setAccessor.name === computed.name);
       return {
-        name: s.name,
-        documentation: buildDocumentation(tsModule, s, checker)
+        name: computed.name,
+        documentation: buildDocumentation(tsModule, computed, checker) +
+        ((setComputed !== undefined) ? buildDocumentation(tsModule, setComputed, checker) : '')
       };
     });
   }
 
-  return undefined;
+  function getObjectComputed (type: ts.Type) {
+    const computedSymbol = checker.getPropertyOfType(type, 'computed');
+    if (!computedSymbol || !computedSymbol.valueDeclaration) {
+      return undefined;
+    }
+
+    const computedDeclaration = getLastChild(computedSymbol.valueDeclaration);
+    if (!computedDeclaration) {
+      return undefined;
+    }
+
+    if (computedDeclaration.kind === tsModule.SyntaxKind.ObjectLiteralExpression) {
+      const computedType = checker.getTypeOfSymbolAtLocation(computedSymbol, computedDeclaration);
+
+      return checker.getPropertiesOfType(computedType).map(s => {
+        return {
+          name: s.name,
+          documentation: buildDocumentation(tsModule, s, checker)
+        };
+      });
+    }
+  }
+
+  return result.length === 0 ? undefined : result;
+}
+
+function isInternalHook (methodName: string) {
+  const $internalHooks = [
+    'data',
+    'beforeCreate',
+    'created',
+    'beforeMount',
+    'mounted',
+    'beforeDestroy',
+    'destroyed',
+    'beforeUpdate',
+    'updated',
+    'activated',
+    'deactivated',
+    'render',
+    'errorCaptured', // 2.5
+    'serverPrefetch' // 2.6
+  ];
+  return $internalHooks.includes(methodName);
 }
 
 function getMethods(
@@ -210,40 +344,78 @@ function getMethods(
   defaultExportType: ts.Type,
   checker: ts.TypeChecker
 ): MethodInfo[] | undefined {
-  const methodsSymbol = checker.getPropertyOfType(defaultExportType, 'methods');
-  if (!methodsSymbol || !methodsSymbol.valueDeclaration) {
-    return undefined;
+  const result: MethodInfo[] = [];
+  if (defaultExportType.isClass()) {
+    result.push.apply(result, getClassMethods(defaultExportType) || []);
+
+    const decoratorArgumentType = checker.getTypeAtLocation(
+      (defaultExportType.symbol.declarations[0].decorators![0].expression as ts.CallExpression).arguments[0]
+    );
+    result.push.apply(result, getObjectMethods(decoratorArgumentType) || []);
+  } else {
+    result.push.apply(result, getObjectMethods(defaultExportType) || []);
   }
 
-  const methodsDeclaration = getLastChild(methodsSymbol.valueDeclaration);
-  if (!methodsDeclaration) {
-    return undefined;
-  }
-
-  if (methodsDeclaration.kind === tsModule.SyntaxKind.ObjectLiteralExpression) {
-    const methodsType = checker.getTypeOfSymbolAtLocation(methodsSymbol, methodsDeclaration);
-
-    return checker.getPropertiesOfType(methodsType).map(s => {
+  function getClassMethods (type: ts.Type) {
+    const methodSymbols = type.getProperties()
+      .filter((property) =>
+        property.valueDeclaration.kind === tsModule.SyntaxKind.MethodDeclaration && (
+          property.declarations[0].decorators === undefined || (
+            property.declarations[0].decorators &&
+            !property.declarations[0].decorators.some((decorator) =>
+              (decorator.expression as ts.CallExpression).expression.getText() === 'Watch'
+            )
+          )
+        ) && !isInternalHook(property.name)
+      );
+    if (methodSymbols.length === 0) { return undefined; }
+
+    return methodSymbols.map((method) => {
       return {
-        name: s.name,
-        documentation: buildDocumentation(tsModule, s, checker)
+        name: method.name,
+        documentation: buildDocumentation(tsModule, method, checker)
       };
     });
   }
 
-  return undefined;
+  function getObjectMethods (type: ts.Type) {
+    const methodsSymbol = checker.getPropertyOfType(type, 'methods');
+    if (!methodsSymbol || !methodsSymbol.valueDeclaration) {
+      return undefined;
+    }
+
+    const methodsDeclaration = getLastChild(methodsSymbol.valueDeclaration);
+    if (!methodsDeclaration) {
+      return undefined;
+    }
+
+    if (methodsDeclaration.kind === tsModule.SyntaxKind.ObjectLiteralExpression) {
+      const methodsType = checker.getTypeOfSymbolAtLocation(methodsSymbol, methodsDeclaration);
+
+      return checker.getPropertiesOfType(methodsType).map(s => {
+        return {
+          name: s.name,
+          documentation: buildDocumentation(tsModule, s, checker)
+        };
+      });
+    }
+  }
+
+  return result.length === 0 ? undefined : result;
 }
 
-export function getObjectLiteralExprFromExportExpr(
+function getNodeFromExportNode(
   tsModule: T_TypeScript,
   exportExpr: ts.Node
-): ts.Expression | undefined {
+): ts.Node | undefined {
   switch (exportExpr.kind) {
     case tsModule.SyntaxKind.CallExpression:
       // Vue.extend or synthetic __vueEditorBridge
       return (exportExpr as ts.CallExpression).arguments[0];
     case tsModule.SyntaxKind.ObjectLiteralExpression:
       return exportExpr as ts.ObjectLiteralExpression;
+    case tsModule.SyntaxKind.ClassDeclaration:
+      return exportExpr as ts.ClassDeclaration;
   }
   return undefined;
 }

From 91d7b2dafd296f3035a766bf5cc470f7ff11c889 Mon Sep 17 00:00:00 2001
From: yoyo930021 <yoyo930021@gmail.com>
Date: Sat, 8 Jun 2019 23:26:53 +0800
Subject: [PATCH 02/14] Fix @Component no argument error

---
 server/src/modes/script/childComponents.ts | 15 +++++--
 server/src/modes/script/componentInfo.ts   | 50 +++++++++++++++-------
 2 files changed, 45 insertions(+), 20 deletions(-)

diff --git a/server/src/modes/script/childComponents.ts b/server/src/modes/script/childComponents.ts
index 026293d275..2089c659ab 100644
--- a/server/src/modes/script/childComponents.ts
+++ b/server/src/modes/script/childComponents.ts
@@ -1,5 +1,10 @@
 import * as ts from 'typescript';
-import { getLastChild, buildDocumentation, getDefaultExportNode } from './componentInfo';
+import {
+  getLastChild,
+  buildDocumentation,
+  getDefaultExportNode,
+  getClassDecoratorArgumentType
+} from './componentInfo';
 import { T_TypeScript } from '../../services/dependencyService';
 
 interface InternalChildComponent {
@@ -22,9 +27,11 @@ export function getChildComponents(
   let type = defaultExportType;
   if (defaultExportType.isClass()) {
     // get decorator argument type when class
-    type = checker.getTypeAtLocation(
-      (defaultExportType.symbol.declarations[0].decorators![0].expression as ts.CallExpression).arguments[0]
-    );
+    const classDecoratorArgumentType = getClassDecoratorArgumentType(tsModule, defaultExportType, checker);
+    if (!classDecoratorArgumentType) {
+      return undefined;
+    }
+    type = classDecoratorArgumentType;
   }
 
   const componentsSymbol = checker.getPropertyOfType(type, 'components');
diff --git a/server/src/modes/script/componentInfo.ts b/server/src/modes/script/componentInfo.ts
index a3b39707a6..4ebec4a620 100644
--- a/server/src/modes/script/componentInfo.ts
+++ b/server/src/modes/script/componentInfo.ts
@@ -103,10 +103,10 @@ function getProps(tsModule: T_TypeScript, defaultExportType: ts.Type, checker: t
   if (defaultExportType.isClass()) {
     result.push.apply(result, getClassProps(defaultExportType) || []);
 
-    const decoratorArgumentType = checker.getTypeAtLocation(
-      (defaultExportType.symbol.declarations[0].decorators![0].expression as ts.CallExpression).arguments[0]
-    );
-    result.push.apply(result, getObjectProps(decoratorArgumentType) || []);
+    const decoratorArgumentType = getClassDecoratorArgumentType(tsModule, defaultExportType, checker);
+    if (decoratorArgumentType) {
+      result.push.apply(result, getObjectProps(decoratorArgumentType) || []);
+    }
   } else {
     result.push.apply(result, getObjectProps(defaultExportType) || []);
   }
@@ -199,10 +199,10 @@ function getData(tsModule: T_TypeScript, defaultExportType: ts.Type, checker: ts
   if (defaultExportType.isClass()) {
     result.push.apply(result, getClassData(defaultExportType) || []);
 
-    const decoratorArgumentType = checker.getTypeAtLocation(
-      (defaultExportType.symbol.declarations[0].decorators![0].expression as ts.CallExpression).arguments[0]
-    );
-    result.push.apply(result, getObjectData(decoratorArgumentType) || []);
+    const decoratorArgumentType = getClassDecoratorArgumentType(tsModule, defaultExportType, checker);
+    if (decoratorArgumentType) {
+      result.push.apply(result, getObjectData(decoratorArgumentType) || []);
+    }
   } else {
     result.push.apply(result, getObjectData(defaultExportType) || []);
   }
@@ -264,10 +264,10 @@ function getComputed(
   if (defaultExportType.isClass()) {
     result.push.apply(result, getClassComputed(defaultExportType) || []);
 
-    const decoratorArgumentType = checker.getTypeAtLocation(
-      (defaultExportType.symbol.declarations[0].decorators![0].expression as ts.CallExpression).arguments[0]
-    );
-    result.push.apply(result, getObjectComputed(decoratorArgumentType) || []);
+    const decoratorArgumentType = getClassDecoratorArgumentType(tsModule, defaultExportType, checker);
+    if (decoratorArgumentType) {
+      result.push.apply(result, getObjectComputed(decoratorArgumentType) || []);
+    }
   } else {
     result.push.apply(result, getObjectComputed(defaultExportType) || []);
   }
@@ -348,10 +348,10 @@ function getMethods(
   if (defaultExportType.isClass()) {
     result.push.apply(result, getClassMethods(defaultExportType) || []);
 
-    const decoratorArgumentType = checker.getTypeAtLocation(
-      (defaultExportType.symbol.declarations[0].decorators![0].expression as ts.CallExpression).arguments[0]
-    );
-    result.push.apply(result, getObjectMethods(decoratorArgumentType) || []);
+    const decoratorArgumentType = getClassDecoratorArgumentType(tsModule, defaultExportType, checker);
+    if (decoratorArgumentType) {
+      result.push.apply(result, getObjectMethods(decoratorArgumentType) || []);
+    }
   } else {
     result.push.apply(result, getObjectMethods(defaultExportType) || []);
   }
@@ -429,6 +429,24 @@ export function getLastChild(d: ts.Declaration) {
   return children[children.length - 1];
 }
 
+export function getClassDecoratorArgumentType(
+  tsModule: T_TypeScript,
+  type: ts.Type,
+  checker: ts.TypeChecker
+) {
+  const decorators = type.symbol.declarations[0].decorators;
+  if (!decorators || decorators.length === 0) {
+    return undefined;
+  }
+
+  const decoratorArguments = (decorators[0].expression as ts.CallExpression).arguments;
+  if (!decoratorArguments || decoratorArguments.length === 0) {
+    return undefined;
+  }
+
+  return checker.getTypeAtLocation(decoratorArguments[0]);
+}
+
 export function buildDocumentation(tsModule: T_TypeScript, s: ts.Symbol, checker: ts.TypeChecker) {
   let documentation = s
     .getDocumentationComment(checker)

From 5c3fd03e3fce9cad65d6463823d19dc09f8d38cf Mon Sep 17 00:00:00 2001
From: yoyo930021 <yoyo930021@gmail.com>
Date: Sun, 23 Jun 2019 22:15:35 +0800
Subject: [PATCH 03/14] Add integration tests for analyzing vue-class-component

---
 test/interpolation/completion/class.test.ts   | 116 ++++++++++++++++++
 .../interpolation/completion/property.test.ts | 110 +++++++++++++++++
 .../fixture/completion/BasicClass.vue         |  45 +++++++
 .../fixture/completion/BasicPropertyClass.vue |  40 ++++++
 .../fixture/completion/ParentClass.vue        |  48 ++++++++
 .../completion/ParentPropertyClass.vue        |  44 +++++++
 test/interpolation/fixture/package.json       |   1 +
 test/interpolation/fixture/yarn.lock          |  13 ++
 8 files changed, 417 insertions(+)
 create mode 100644 test/interpolation/completion/class.test.ts
 create mode 100644 test/interpolation/completion/property.test.ts
 create mode 100644 test/interpolation/fixture/completion/BasicClass.vue
 create mode 100644 test/interpolation/fixture/completion/BasicPropertyClass.vue
 create mode 100644 test/interpolation/fixture/completion/ParentClass.vue
 create mode 100644 test/interpolation/fixture/completion/ParentPropertyClass.vue

diff --git a/test/interpolation/completion/class.test.ts b/test/interpolation/completion/class.test.ts
new file mode 100644
index 0000000000..7037b06f16
--- /dev/null
+++ b/test/interpolation/completion/class.test.ts
@@ -0,0 +1,116 @@
+import { activateLS, showFile, sleep, FILE_LOAD_SLEEP_TIME } from '../../lsp/helper';
+import { position, getDocUri } from '../util';
+import { testCompletion, testNoSuchCompletion } from './helper';
+import { CompletionItem, CompletionItemKind, MarkdownString } from 'vscode';
+
+describe('Should autocomplete interpolation for <template> in class component', () => {
+  const templateDocUri = getDocUri('completion/BasicClass.vue');
+  const parentTemplateDocUri = getDocUri('completion/ParentClass.vue');
+
+  before('activate', async () => {
+    await activateLS();
+    await showFile(templateDocUri);
+    await sleep(FILE_LOAD_SLEEP_TIME);
+    await sleep(FILE_LOAD_SLEEP_TIME);
+  });
+
+  const defaultList: CompletionItem[] = [
+    {
+      label: 'foo',
+      documentation: new MarkdownString('My foo').appendCodeblock(
+        `foo: {
+  type: Boolean,
+  default: false
+}`,
+        'js'
+      ),
+      kind: CompletionItemKind.Property
+    },
+    {
+      label: 'msg',
+      documentation: new MarkdownString('My msg').appendCodeblock(`msg = 'Vetur means "Winter" in icelandic.'`, 'js'),
+      kind: CompletionItemKind.Property
+    },
+    {
+      label: 'count',
+      documentation: new MarkdownString('My count').appendCodeblock(
+        `get count () {
+  return this.$store.state.count
+}`,
+        'js'
+      ),
+      kind: CompletionItemKind.Property
+    },
+    {
+      label: 'hello',
+      documentation: new MarkdownString('My greeting').appendCodeblock(
+        `hello () {
+  console.log(this.msg)
+}`,
+        'js'
+      ),
+
+      kind: CompletionItemKind.Method
+    }
+  ];
+
+  describe('Should complete props, data, computed and methods', () => {
+    it('completes inside {{ }}', async () => {
+      await testCompletion(templateDocUri, position(2, 7), defaultList);
+    });
+
+    it(`completes child component tag`, async () => {
+      await testCompletion(parentTemplateDocUri, position(4, 5), [
+        {
+          label: 'basic-class',
+          documentationStart: 'My basic tag\n```js\n@Component('
+        }
+      ]);
+    });
+
+    it(`completes child component's props`, async () => {
+      await testCompletion(parentTemplateDocUri, position(2, 18), [
+        {
+          label: 'foo',
+          documentation: new MarkdownString('My foo').appendCodeblock(
+            `foo: {
+  type: Boolean,
+  default: false
+}`,
+            'js'
+          )
+        }
+      ]);
+    });
+
+    it('completes inside v-if=""', async () => {
+      await testCompletion(parentTemplateDocUri, position(3, 23), defaultList);
+    });
+    it(`doesn't completes on the edge " of v-if=""`, async () => {
+      await testNoSuchCompletion(parentTemplateDocUri, position(3, 22), defaultList);
+    });
+    it(`doesn't completes on the edge " of v-if=""`, async () => {
+      await testNoSuchCompletion(parentTemplateDocUri, position(3, 24), defaultList);
+    });
+
+    it('completes inside @click=""', async () => {
+      await testCompletion(parentTemplateDocUri, position(3, 33), defaultList);
+    });
+    it(`doesn't completes on the edge " of @click=""`, async () => {
+      await testNoSuchCompletion(parentTemplateDocUri, position(3, 32), defaultList);
+    });
+    it(`doesn't completes on the edge " of @click=""`, async () => {
+      await testNoSuchCompletion(parentTemplateDocUri, position(3, 34), defaultList);
+    });
+
+    it('completes inside :foo=""', async () => {
+      await testCompletion(parentTemplateDocUri, position(3, 41), defaultList);
+    });
+    it(`doesn't completes on the edge " of :foo=""`, async () => {
+      await testNoSuchCompletion(parentTemplateDocUri, position(3, 40), defaultList);
+    });
+    it(`doesn't completes on the edge " of :foo=""`, async () => {
+      await testNoSuchCompletion(parentTemplateDocUri, position(3, 42), defaultList);
+    });
+  });
+});
diff --git a/test/interpolation/completion/property.test.ts b/test/interpolation/completion/property.test.ts
new file mode 100644
index 0000000000..8dd15df696
--- /dev/null
+++ b/test/interpolation/completion/property.test.ts
@@ -0,0 +1,110 @@
+import { activateLS, showFile, sleep, FILE_LOAD_SLEEP_TIME } from '../../lsp/helper';
+import { position, getDocUri } from '../util';
+import { testCompletion, testNoSuchCompletion } from './helper';
+import { CompletionItem, CompletionItemKind, MarkdownString } from 'vscode';
+
+describe('Should autocomplete interpolation for <template> in property class component', () => {
+  const templateDocUri = getDocUri('completion/BasicPropertyClass.vue');
+  const parentTemplateDocUri = getDocUri('completion/ParentPropertyClass.vue');
+
+  before('activate', async () => {
+    await activateLS();
+    await showFile(templateDocUri);
+    await sleep(FILE_LOAD_SLEEP_TIME);
+    await sleep(FILE_LOAD_SLEEP_TIME);
+  });
+
+  const defaultList: CompletionItem[] = [
+    {
+      label: 'foo',
+      documentation: new MarkdownString('My foo').appendCodeblock(
+        `@Prop({ type: Boolean, default: false }) foo`,
+        'js'
+      ),
+      kind: CompletionItemKind.Property
+    },
+    {
+      label: 'msg',
+      documentation: new MarkdownString('My msg').appendCodeblock(`msg = 'Vetur means "Winter" in icelandic.'`, 'js'),
+      kind: CompletionItemKind.Property
+    },
+    {
+      label: 'count',
+      documentation: new MarkdownString('My count').appendCodeblock(
+        `get count () {
+  return this.$store.state.count
+}`,
+        'js'
+      ),
+      kind: CompletionItemKind.Property
+    },
+    {
+      label: 'hello',
+      documentation: new MarkdownString('My greeting').appendCodeblock(
+        `hello () {
+  console.log(this.msg)
+}`,
+        'js'
+      ),
+
+      kind: CompletionItemKind.Method
+    }
+  ];
+
+  describe('Should complete props, data, computed and methods', () => {
+    it('completes inside {{ }}', async () => {
+      await testCompletion(templateDocUri, position(2, 7), defaultList);
+    });
+
+    it(`completes child component tag`, async () => {
+      await testCompletion(parentTemplateDocUri, position(4, 5), [
+        {
+          label: 'basic-property-class',
+          documentationStart: 'My basic tag\n```js\n@Component('
+        }
+      ]);
+    });
+
+    it(`completes child component's props`, async () => {
+      await testCompletion(parentTemplateDocUri, position(2, 27), [
+        {
+          label: 'foo',
+          documentation: new MarkdownString('My foo').appendCodeblock(
+            `@Prop({ type: Boolean, default: false }) foo`,
+            'js'
+          )
+        }
+      ]);
+    });
+
+    it('completes inside v-if=""', async () => {
+      await testCompletion(parentTemplateDocUri, position(3, 32), defaultList);
+    });
+    it(`doesn't completes on the edge " of v-if=""`, async () => {
+      await testNoSuchCompletion(parentTemplateDocUri, position(3, 31), defaultList);
+    });
+    it(`doesn't completes on the edge " of v-if=""`, async () => {
+      await testNoSuchCompletion(parentTemplateDocUri, position(3, 33), defaultList);
+    });
+
+    it('completes inside @click=""', async () => {
+      await testCompletion(parentTemplateDocUri, position(3, 42), defaultList);
+    });
+    it(`doesn't completes on the edge " of @click=""`, async () => {
+      await testNoSuchCompletion(parentTemplateDocUri, position(3, 41), defaultList);
+    });
+    it(`doesn't completes on the edge " of @click=""`, async () => {
+      await testNoSuchCompletion(parentTemplateDocUri, position(3, 43), defaultList);
+    });
+
+    it('completes inside :foo=""', async () => {
+      await testCompletion(parentTemplateDocUri, position(3, 50), defaultList);
+    });
+    it(`doesn't completes on the edge " of :foo=""`, async () => {
+      await testNoSuchCompletion(parentTemplateDocUri, position(3, 49), defaultList);
+    });
+    it(`doesn't completes on the edge " of :foo=""`, async () => {
+      await testNoSuchCompletion(parentTemplateDocUri, position(3, 51), defaultList);
+    });
+  });
+});
diff --git a/test/interpolation/fixture/completion/BasicClass.vue b/test/interpolation/fixture/completion/BasicClass.vue
new file mode 100644
index 0000000000..629d74923f
--- /dev/null
+++ b/test/interpolation/fixture/completion/BasicClass.vue
@@ -0,0 +1,45 @@
+<template>
+  <div>
+    {{  }}
+  </div>
+</template>
+
+<script>
+import Vue from 'vue'
+import Component from 'vue-class-component'
+
+/**
+ * My basic tag
+ */
+@Component({
+  props: {
+    /**
+     * My foo
+     */
+    foo: {
+      type: Boolean,
+      default: false
+    }
+  }
+})
+export default class BasicClass extends Vue {
+  /**
+   * My msg
+   */
+  msg = 'Vetur means "Winter" in icelandic.'
+
+  /**
+   * My count
+   */
+  get count () {
+    return this.$store.state.count
+  }
+
+  /**
+   * My greeting
+   */
+  hello () {
+    console.log(this.msg)
+  }
+}
+</script>
diff --git a/test/interpolation/fixture/completion/BasicPropertyClass.vue b/test/interpolation/fixture/completion/BasicPropertyClass.vue
new file mode 100644
index 0000000000..66408c7100
--- /dev/null
+++ b/test/interpolation/fixture/completion/BasicPropertyClass.vue
@@ -0,0 +1,40 @@
+<template>
+  <div>
+    {{  }}
+  </div>
+</template>
+
+<script>
+import Vue from 'vue'
+import { Prop, Component } from 'vue-property-decorator'
+
+/**
+ * My basic tag
+ */
+@Component()
+export default class BasicPropertyClass extends Vue {
+  /**
+   * My foo
+   */
+  @Prop({ type: Boolean, default: false }) foo
+
+  /**
+   * My msg
+   */
+  msg = 'Vetur means "Winter" in icelandic.'
+
+  /**
+   * My count
+   */
+  get count () {
+    return this.$store.state.count
+  }
+
+  /**
+   * My greeting
+   */
+  hello () {
+    console.log(this.msg)
+  }
+}
+</script>
diff --git a/test/interpolation/fixture/completion/ParentClass.vue b/test/interpolation/fixture/completion/ParentClass.vue
new file mode 100644
index 0000000000..eed414afd4
--- /dev/null
+++ b/test/interpolation/fixture/completion/ParentClass.vue
@@ -0,0 +1,48 @@
+<template>
+  <div>
+    <basic-class :></basic-class>
+    <basic-class v-if="" @click="" :foo=""></basic-class>
+    <
+  </div>
+</template>
+
+<script>
+import Vue from 'vue'
+import BasicClass from './BasicClass.vue'
+import Component from 'vue-class-component'
+
+@Component({
+  components: {
+    BasicClass
+  },
+  props: {
+    /**
+     * My foo
+     */
+    foo: {
+      type: Boolean,
+      default: false
+    },
+  }
+})
+export default class ParentClass extends Vue {
+  /**
+   * My msg
+   */
+  msg = 'Vetur means "Winter" in icelandic.'
+
+  /**
+   * My count
+   */
+  get count () {
+    return this.$store.state.count
+  }
+
+  /**
+   * My greeting
+   */
+  hello () {
+    console.log(this.msg)
+  }
+}
+</script>
diff --git a/test/interpolation/fixture/completion/ParentPropertyClass.vue b/test/interpolation/fixture/completion/ParentPropertyClass.vue
new file mode 100644
index 0000000000..f0756bcc13
--- /dev/null
+++ b/test/interpolation/fixture/completion/ParentPropertyClass.vue
@@ -0,0 +1,44 @@
+<template>
+  <div>
+    <basic-property-class :></basic-property-class>
+    <basic-property-class v-if="" @click="" :foo=""></basic-property-class>
+    <
+  </div>
+</template>
+
+<script>
+import Vue from 'vue'
+import BasicPropertyClass from './BasicPropertyClass.vue'
+import { Prop, Component } from 'vue-property-decorator'
+
+@Component({
+  components: {
+    BasicPropertyClass
+  }
+})
+export default class ParentClass extends Vue {
+  /**
+   * My foo
+   */
+  @Prop({ type: Boolean, default: false }) foo
+
+  /**
+   * My msg
+   */
+  msg = 'Vetur means "Winter" in icelandic.'
+
+  /**
+   * My count
+   */
+  get count () {
+    return this.$store.state.count
+  }
+
+  /**
+   * My greeting
+   */
+  hello () {
+    console.log(this.msg)
+  }
+}
+</script>
diff --git a/test/interpolation/fixture/package.json b/test/interpolation/fixture/package.json
index 96ad7d9f22..49c3097c1b 100644
--- a/test/interpolation/fixture/package.json
+++ b/test/interpolation/fixture/package.json
@@ -2,6 +2,7 @@
   "dependencies": {
     "vue": "^2.6.11",
     "vue-class-component": "^7.0.2",
+    "vue-property-decorator": "^8.2.1",
     "vue-router": "^3.0.6",
     "vuex": "^3.1.0"
   }
diff --git a/test/interpolation/fixture/yarn.lock b/test/interpolation/fixture/yarn.lock
index 37def43099..4a61058dc6 100644
--- a/test/interpolation/fixture/yarn.lock
+++ b/test/interpolation/fixture/yarn.lock
@@ -2,11 +2,24 @@
 # yarn lockfile v1
 
 
+vue-class-component@^7.0.1:
+  version "7.1.0"
+  resolved "https://registry.yarnpkg.com/vue-class-component/-/vue-class-component-7.1.0.tgz#b33efcb10e17236d684f70b1e96f1946ec793e87"
+  integrity sha512-G9152NzUkz0i0xTfhk0Afc8vzdXxDR1pfN4dTwE72cskkgJtdXfrKBkMfGvDuxUh35U500g5Ve4xL8PEGdWeHg==
+
 vue-class-component@^7.0.2:
   version "7.0.2"
   resolved "https://registry.yarnpkg.com/vue-class-component/-/vue-class-component-7.0.2.tgz#c5f35a91c0e9341532392b84d606a84911fb13bc"
   integrity sha512-8xw/wkZI2tgHcwvkSRC1ax7GeP1CG27wKhedvOAdjdASm05VU4RijGsCYti6s6CzBioBL5BQUmntQQTCsp1wnQ==
 
+vue-property-decorator@^8.2.1:
+  version "8.2.1"
+  resolved "https://registry.yarnpkg.com/vue-property-decorator/-/vue-property-decorator-8.2.1.tgz#3791662033b20d20d098cb20e86fd23842982508"
+  integrity sha512-zgtcvzGB2JpDqnIxVhTK+6m+dv3uyhYs+tL8elL+DWiXj9kDonKcPY7f1DHYX1NlnWPCj7ht0nL/i8+S1gg76Q==
+  dependencies:
+    vue "^2.6.10"
+    vue-class-component "^7.0.1"
+
 vue-router@^3.0.6:
   version "3.0.6"
   resolved "https://registry.yarnpkg.com/vue-router/-/vue-router-3.0.6.tgz#2e4f0f9cbb0b96d0205ab2690cfe588935136ac3"

From 3ce9ca7b41affd57615e94e3b8bc391a4c759ddf Mon Sep 17 00:00:00 2001
From: yoyo930021 <yoyo930021@gmail.com>
Date: Sun, 7 Jul 2019 16:42:02 +0800
Subject: [PATCH 04/14] Fix isClass function undefined in Typescript 2.8

---
 server/src/modes/script/childComponents.ts |  5 +++--
 server/src/modes/script/componentInfo.ts   | 20 ++++++++++++++++----
 2 files changed, 19 insertions(+), 6 deletions(-)

diff --git a/server/src/modes/script/childComponents.ts b/server/src/modes/script/childComponents.ts
index 2089c659ab..146a6acec8 100644
--- a/server/src/modes/script/childComponents.ts
+++ b/server/src/modes/script/childComponents.ts
@@ -3,7 +3,8 @@ import {
   getLastChild,
   buildDocumentation,
   getDefaultExportNode,
-  getClassDecoratorArgumentType
+  getClassDecoratorArgumentType,
+  isClassType
 } from './componentInfo';
 import { T_TypeScript } from '../../services/dependencyService';
 
@@ -25,7 +26,7 @@ export function getChildComponents(
   tagCasing = 'kebab'
 ): InternalChildComponent[] | undefined {
   let type = defaultExportType;
-  if (defaultExportType.isClass()) {
+  if (isClassType(tsModule, type)) {
     // get decorator argument type when class
     const classDecoratorArgumentType = getClassDecoratorArgumentType(tsModule, defaultExportType, checker);
     if (!classDecoratorArgumentType) {
diff --git a/server/src/modes/script/componentInfo.ts b/server/src/modes/script/componentInfo.ts
index 4ebec4a620..4820aac63c 100644
--- a/server/src/modes/script/componentInfo.ts
+++ b/server/src/modes/script/componentInfo.ts
@@ -100,7 +100,7 @@ export function getDefaultExportNode(
 
 function getProps(tsModule: T_TypeScript, defaultExportType: ts.Type, checker: ts.TypeChecker): PropInfo[] | undefined {
   const result: PropInfo[] = [];
-  if (defaultExportType.isClass()) {
+  if (isClassType(tsModule, defaultExportType)) {
     result.push.apply(result, getClassProps(defaultExportType) || []);
 
     const decoratorArgumentType = getClassDecoratorArgumentType(tsModule, defaultExportType, checker);
@@ -196,7 +196,7 @@ function getProps(tsModule: T_TypeScript, defaultExportType: ts.Type, checker: t
  */
 function getData(tsModule: T_TypeScript, defaultExportType: ts.Type, checker: ts.TypeChecker): DataInfo[] | undefined {
   const result: DataInfo[] = [];
-  if (defaultExportType.isClass()) {
+  if (isClassType(tsModule, defaultExportType)) {
     result.push.apply(result, getClassData(defaultExportType) || []);
 
     const decoratorArgumentType = getClassDecoratorArgumentType(tsModule, defaultExportType, checker);
@@ -261,7 +261,7 @@ function getComputed(
   checker: ts.TypeChecker
 ): ComputedInfo[] | undefined {
   const result: ComputedInfo[] = [];
-  if (defaultExportType.isClass()) {
+  if (isClassType(tsModule, defaultExportType)) {
     result.push.apply(result, getClassComputed(defaultExportType) || []);
 
     const decoratorArgumentType = getClassDecoratorArgumentType(tsModule, defaultExportType, checker);
@@ -345,7 +345,7 @@ function getMethods(
   checker: ts.TypeChecker
 ): MethodInfo[] | undefined {
   const result: MethodInfo[] = [];
-  if (defaultExportType.isClass()) {
+  if (isClassType(tsModule, defaultExportType)) {
     result.push.apply(result, getClassMethods(defaultExportType) || []);
 
     const decoratorArgumentType = getClassDecoratorArgumentType(tsModule, defaultExportType, checker);
@@ -429,6 +429,18 @@ export function getLastChild(d: ts.Declaration) {
   return children[children.length - 1];
 }
 
+export function isClassType (
+  tsModule: T_TypeScript,
+  type: ts.Type
+) {
+  if (type.isClass === undefined) {
+    return !!((type.flags & tsModule.TypeFlags.Object ? (type as ts.ObjectType).objectFlags : 0)
+    & tsModule.ObjectFlags.Class);
+  } else {
+    return type.isClass();
+  }
+}
+
 export function getClassDecoratorArgumentType(
   tsModule: T_TypeScript,
   type: ts.Type,

From 0f754cd79f1861bac2d922c3c0a9c5f7d1ae56a7 Mon Sep 17 00:00:00 2001
From: yoyo930021 <yoyo930021@gmail.com>
Date: Tue, 30 Jul 2019 20:31:27 +0800
Subject: [PATCH 05/14] Add new version vue-property-decorator support

---
 server/src/modes/script/componentInfo.ts | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/server/src/modes/script/componentInfo.ts b/server/src/modes/script/componentInfo.ts
index 4820aac63c..41a0fa4059 100644
--- a/server/src/modes/script/componentInfo.ts
+++ b/server/src/modes/script/componentInfo.ts
@@ -112,13 +112,13 @@ function getProps(tsModule: T_TypeScript, defaultExportType: ts.Type, checker: t
   }
 
   function getClassProps (type: ts.Type) {
+    const propDecoratorNames = ['Prop', 'Model', 'PropSync'];
     const propsSymbols = type.getProperties()
       .filter((property) =>
         property.valueDeclaration.kind === tsModule.SyntaxKind.PropertyDeclaration &&
         property.declarations[0].decorators &&
         property.declarations[0].decorators.some((decorator) =>
-          (decorator.expression as ts.CallExpression).expression.getText() === 'Prop' ||
-          (decorator.expression as ts.CallExpression).expression.getText() === 'Model'
+          propDecoratorNames.includes((decorator.expression as ts.CallExpression).expression.getText())
         )
       );
     if (propsSymbols.length === 0) { return undefined; }
@@ -208,15 +208,14 @@ function getData(tsModule: T_TypeScript, defaultExportType: ts.Type, checker: ts
   }
 
   function getClassData (type: ts.Type) {
+    const noDataDecoratorNames = ['Prop', 'Model', 'Provide', 'ProvideReactive', 'Ref'];
     const dataSymbols = type.getProperties()
       .filter((property) =>
         property.valueDeclaration.kind === tsModule.SyntaxKind.PropertyDeclaration && (
           property.declarations[0].decorators === undefined || (
             property.declarations[0].decorators &&
             !property.declarations[0].decorators.some((decorator) =>
-              (decorator.expression as ts.CallExpression).expression.getText() === 'Prop' ||
-              (decorator.expression as ts.CallExpression).expression.getText() === 'Model' ||
-              (decorator.expression as ts.CallExpression).expression.getText() === 'Inject'
+              noDataDecoratorNames.includes((decorator.expression as ts.CallExpression).expression.getText())
             )
           )
         ) &&

From 0804b0ce27d28e95ece1292d88f7a93e0094cbfd Mon Sep 17 00:00:00 2001
From: yoyo930021 <yoyo930021@gmail.com>
Date: Fri, 23 Aug 2019 12:56:58 +0800
Subject: [PATCH 06/14] Refactor analyze component logic

---
 server/src/modes/script/componentInfo.ts | 233 ++++++++++++-----------
 1 file changed, 122 insertions(+), 111 deletions(-)

diff --git a/server/src/modes/script/componentInfo.ts b/server/src/modes/script/componentInfo.ts
index 41a0fa4059..2539254d47 100644
--- a/server/src/modes/script/componentInfo.ts
+++ b/server/src/modes/script/componentInfo.ts
@@ -92,38 +92,31 @@ export function getDefaultExportNode(
   if (exportStmts.length === 0) {
     return undefined;
   }
-  const exportNode = (exportStmts[0].kind === tsModule.SyntaxKind.ExportAssignment) ?
-    (exportStmts[0] as ts.ExportAssignment).expression : (exportStmts[0] as ts.ClassDeclaration);
+  const exportNode =
+    exportStmts[0].kind === tsModule.SyntaxKind.ExportAssignment
+      ? (exportStmts[0] as ts.ExportAssignment).expression
+      : (exportStmts[0] as ts.ClassDeclaration);
 
   return getNodeFromExportNode(tsModule, exportNode);
 }
 
 function getProps(tsModule: T_TypeScript, defaultExportType: ts.Type, checker: ts.TypeChecker): PropInfo[] | undefined {
-  const result: PropInfo[] = [];
-  if (isClassType(tsModule, defaultExportType)) {
-    result.push.apply(result, getClassProps(defaultExportType) || []);
+  const result: PropInfo[] = getClassAndObjectInfo(tsModule, defaultExportType, checker, getClassProps, getObjectProps);
 
-    const decoratorArgumentType = getClassDecoratorArgumentType(tsModule, defaultExportType, checker);
-    if (decoratorArgumentType) {
-      result.push.apply(result, getObjectProps(decoratorArgumentType) || []);
-    }
-  } else {
-    result.push.apply(result, getObjectProps(defaultExportType) || []);
-  }
-
-  function getClassProps (type: ts.Type) {
+  function getClassProps(type: ts.Type) {
     const propDecoratorNames = ['Prop', 'Model', 'PropSync'];
-    const propsSymbols = type.getProperties()
-      .filter((property) =>
-        property.valueDeclaration.kind === tsModule.SyntaxKind.PropertyDeclaration &&
-        property.declarations[0].decorators &&
-        property.declarations[0].decorators.some((decorator) =>
-          propDecoratorNames.includes((decorator.expression as ts.CallExpression).expression.getText())
+    const propsSymbols = type
+      .getProperties()
+      .filter(property =>
+        getPropertyDecoratorNames(property, tsModule.SyntaxKind.PropertyDeclaration).some(decoratorName =>
+          propDecoratorNames.includes(decoratorName)
         )
       );
-    if (propsSymbols.length === 0) { return undefined; }
+    if (propsSymbols.length === 0) {
+      return undefined;
+    }
 
-    return propsSymbols.map((prop) => {
+    return propsSymbols.map(prop => {
       return {
         name: prop.name,
         documentation: buildDocumentation(tsModule, prop, checker)
@@ -131,7 +124,7 @@ function getProps(tsModule: T_TypeScript, defaultExportType: ts.Type, checker: t
     });
   }
 
-  function getObjectProps (type: ts.Type) {
+  function getObjectProps(type: ts.Type) {
     const propsSymbol = checker.getPropertyOfType(type, 'props');
     if (!propsSymbol || !propsSymbol.valueDeclaration) {
       return undefined;
@@ -176,6 +169,8 @@ function getProps(tsModule: T_TypeScript, defaultExportType: ts.Type, checker: t
         };
       });
     }
+
+    return undefined;
   }
 
   return result.length === 0 ? undefined : result;
@@ -195,35 +190,25 @@ function getProps(tsModule: T_TypeScript, defaultExportType: ts.Type, checker: t
  * ```
  */
 function getData(tsModule: T_TypeScript, defaultExportType: ts.Type, checker: ts.TypeChecker): DataInfo[] | undefined {
-  const result: DataInfo[] = [];
-  if (isClassType(tsModule, defaultExportType)) {
-    result.push.apply(result, getClassData(defaultExportType) || []);
-
-    const decoratorArgumentType = getClassDecoratorArgumentType(tsModule, defaultExportType, checker);
-    if (decoratorArgumentType) {
-      result.push.apply(result, getObjectData(decoratorArgumentType) || []);
-    }
-  } else {
-    result.push.apply(result, getObjectData(defaultExportType) || []);
-  }
+  const result: DataInfo[] = getClassAndObjectInfo(tsModule, defaultExportType, checker, getClassData, getObjectData);
 
-  function getClassData (type: ts.Type) {
+  function getClassData(type: ts.Type) {
     const noDataDecoratorNames = ['Prop', 'Model', 'Provide', 'ProvideReactive', 'Ref'];
-    const dataSymbols = type.getProperties()
-      .filter((property) =>
-        property.valueDeclaration.kind === tsModule.SyntaxKind.PropertyDeclaration && (
-          property.declarations[0].decorators === undefined || (
-            property.declarations[0].decorators &&
-            !property.declarations[0].decorators.some((decorator) =>
-              noDataDecoratorNames.includes((decorator.expression as ts.CallExpression).expression.getText())
-            )
-          )
-        ) &&
-        !property.name.startsWith('_') && !property.name.startsWith('$')
+    const dataSymbols = type
+      .getProperties()
+      .filter(
+        property =>
+          !getPropertyDecoratorNames(property, tsModule.SyntaxKind.PropertyDeclaration).some(decoratorName =>
+            noDataDecoratorNames.includes(decoratorName)
+          ) &&
+          !property.name.startsWith('_') &&
+          !property.name.startsWith('$')
       );
-    if (dataSymbols.length === 0) { return undefined; }
+    if (dataSymbols.length === 0) {
+      return undefined;
+    }
 
-    return dataSymbols.map((data) => {
+    return dataSymbols.map(data => {
       return {
         name: data.name,
         documentation: buildDocumentation(tsModule, data, checker)
@@ -231,7 +216,7 @@ function getData(tsModule: T_TypeScript, defaultExportType: ts.Type, checker: ts
     });
   }
 
-  function getObjectData (type: ts.Type) {
+  function getObjectData(type: ts.Type) {
     const dataSymbol = checker.getPropertyOfType(type, 'data');
     if (!dataSymbol || !dataSymbol.valueDeclaration) {
       return undefined;
@@ -259,40 +244,37 @@ function getComputed(
   defaultExportType: ts.Type,
   checker: ts.TypeChecker
 ): ComputedInfo[] | undefined {
-  const result: ComputedInfo[] = [];
-  if (isClassType(tsModule, defaultExportType)) {
-    result.push.apply(result, getClassComputed(defaultExportType) || []);
+  const result: ComputedInfo[] = getClassAndObjectInfo(
+    tsModule,
+    defaultExportType,
+    checker,
+    getClassComputed,
+    getObjectComputed
+  );
 
-    const decoratorArgumentType = getClassDecoratorArgumentType(tsModule, defaultExportType, checker);
-    if (decoratorArgumentType) {
-      result.push.apply(result, getObjectComputed(decoratorArgumentType) || []);
+  function getClassComputed(type: ts.Type) {
+    const getAccessorSymbols = type
+      .getProperties()
+      .filter(property => property.valueDeclaration.kind === tsModule.SyntaxKind.GetAccessor);
+    const setAccessorSymbols = defaultExportType
+      .getProperties()
+      .filter(property => property.valueDeclaration.kind === tsModule.SyntaxKind.SetAccessor);
+    if (getAccessorSymbols.length === 0) {
+      return undefined;
     }
-  } else {
-    result.push.apply(result, getObjectComputed(defaultExportType) || []);
-  }
 
-  function getClassComputed (type: ts.Type) {
-    const getAccessorSymbols = type.getProperties()
-      .filter((property) =>
-        property.valueDeclaration.kind === tsModule.SyntaxKind.GetAccessor
-      );
-    const setAccessorSymbols = defaultExportType.getProperties()
-    .filter((property) =>
-      property.valueDeclaration.kind === tsModule.SyntaxKind.SetAccessor
-    );
-    if (getAccessorSymbols.length === 0) { return undefined; }
-
-    return getAccessorSymbols.map((computed) => {
-      const setComputed = setAccessorSymbols.find((setAccessor) => setAccessor.name === computed.name);
+    return getAccessorSymbols.map(computed => {
+      const setComputed = setAccessorSymbols.find(setAccessor => setAccessor.name === computed.name);
       return {
         name: computed.name,
-        documentation: buildDocumentation(tsModule, computed, checker) +
-        ((setComputed !== undefined) ? buildDocumentation(tsModule, setComputed, checker) : '')
+        documentation:
+          buildDocumentation(tsModule, computed, checker) +
+          (setComputed !== undefined ? buildDocumentation(tsModule, setComputed, checker) : '')
       };
     });
   }
 
-  function getObjectComputed (type: ts.Type) {
+  function getObjectComputed(type: ts.Type) {
     const computedSymbol = checker.getPropertyOfType(type, 'computed');
     if (!computedSymbol || !computedSymbol.valueDeclaration) {
       return undefined;
@@ -318,7 +300,7 @@ function getComputed(
   return result.length === 0 ? undefined : result;
 }
 
-function isInternalHook (methodName: string) {
+function isInternalHook(methodName: string) {
   const $internalHooks = [
     'data',
     'beforeCreate',
@@ -343,33 +325,28 @@ function getMethods(
   defaultExportType: ts.Type,
   checker: ts.TypeChecker
 ): MethodInfo[] | undefined {
-  const result: MethodInfo[] = [];
-  if (isClassType(tsModule, defaultExportType)) {
-    result.push.apply(result, getClassMethods(defaultExportType) || []);
-
-    const decoratorArgumentType = getClassDecoratorArgumentType(tsModule, defaultExportType, checker);
-    if (decoratorArgumentType) {
-      result.push.apply(result, getObjectMethods(decoratorArgumentType) || []);
-    }
-  } else {
-    result.push.apply(result, getObjectMethods(defaultExportType) || []);
-  }
+  const result: MethodInfo[] = getClassAndObjectInfo(
+    tsModule,
+    defaultExportType,
+    checker,
+    getClassMethods,
+    getObjectMethods
+  );
 
-  function getClassMethods (type: ts.Type) {
-    const methodSymbols = type.getProperties()
-      .filter((property) =>
-        property.valueDeclaration.kind === tsModule.SyntaxKind.MethodDeclaration && (
-          property.declarations[0].decorators === undefined || (
-            property.declarations[0].decorators &&
-            !property.declarations[0].decorators.some((decorator) =>
-              (decorator.expression as ts.CallExpression).expression.getText() === 'Watch'
-            )
-          )
-        ) && !isInternalHook(property.name)
+  function getClassMethods(type: ts.Type) {
+    const methodSymbols = type
+      .getProperties()
+      .filter(
+        property =>
+          !getPropertyDecoratorNames(property, tsModule.SyntaxKind.MethodDeclaration).some(
+            decoratorName => decoratorName === 'Watch'
+          ) && !isInternalHook(property.name)
       );
-    if (methodSymbols.length === 0) { return undefined; }
+    if (methodSymbols.length === 0) {
+      return undefined;
+    }
 
-    return methodSymbols.map((method) => {
+    return methodSymbols.map(method => {
       return {
         name: method.name,
         documentation: buildDocumentation(tsModule, method, checker)
@@ -377,7 +354,7 @@ function getMethods(
     });
   }
 
-  function getObjectMethods (type: ts.Type) {
+  function getObjectMethods(type: ts.Type) {
     const methodsSymbol = checker.getPropertyOfType(type, 'methods');
     if (!methodsSymbol || !methodsSymbol.valueDeclaration) {
       return undefined;
@@ -428,23 +405,17 @@ export function getLastChild(d: ts.Declaration) {
   return children[children.length - 1];
 }
 
-export function isClassType (
-  tsModule: T_TypeScript,
-  type: ts.Type
-) {
+export function isClassType(tsModule: T_TypeScript, type: ts.Type) {
   if (type.isClass === undefined) {
-    return !!((type.flags & tsModule.TypeFlags.Object ? (type as ts.ObjectType).objectFlags : 0)
-    & tsModule.ObjectFlags.Class);
+    return !!(
+      (type.flags & tsModule.TypeFlags.Object ? (type as ts.ObjectType).objectFlags : 0) & tsModule.ObjectFlags.Class
+    );
   } else {
     return type.isClass();
   }
 }
 
-export function getClassDecoratorArgumentType(
-  tsModule: T_TypeScript,
-  type: ts.Type,
-  checker: ts.TypeChecker
-) {
+export function getClassDecoratorArgumentType(tsModule: T_TypeScript, type: ts.Type, checker: ts.TypeChecker) {
   const decorators = type.symbol.declarations[0].decorators;
   if (!decorators || decorators.length === 0) {
     return undefined;
@@ -458,6 +429,46 @@ export function getClassDecoratorArgumentType(
   return checker.getTypeAtLocation(decoratorArguments[0]);
 }
 
+function getClassAndObjectInfo<C, O>(
+  tsModule: T_TypeScript,
+  defaultExportType: ts.Type,
+  checker: ts.TypeChecker,
+  getClassResult: (type: ts.Type) => C[] | undefined,
+  getObjectResult: (type: ts.Type) => O[] | undefined
+) {
+  const result: Array<C | O> = [];
+  if (isClassType(tsModule, defaultExportType)) {
+    result.push.apply(result, getClassResult(defaultExportType) || []);
+    const decoratorArgumentType = getClassDecoratorArgumentType(tsModule, defaultExportType, checker);
+    if (decoratorArgumentType) {
+      result.push.apply(result, getObjectResult(decoratorArgumentType) || []);
+    }
+  } else {
+    result.push.apply(result, getObjectResult(defaultExportType) || []);
+  }
+  return result;
+}
+
+function getPropertyDecoratorNames(property: ts.Symbol, checkSyntaxKind: ts.SyntaxKind): string[] {
+  if (property.valueDeclaration.kind !== checkSyntaxKind) {
+    return [];
+  }
+
+  if (property.declarations.length === 0) {
+    return [];
+  }
+
+  const decorators = property.declarations[0].decorators;
+  if (decorators === undefined) {
+    return [];
+  }
+
+  return decorators
+    .map(decorator => decorator.expression as ts.CallExpression)
+    .filter(decoratorExpression => decoratorExpression.expression !== undefined)
+    .map(decoratorExpression => decoratorExpression.expression.getText());
+}
+
 export function buildDocumentation(tsModule: T_TypeScript, s: ts.Symbol, checker: ts.TypeChecker) {
   let documentation = s
     .getDocumentationComment(checker)

From 24e0f1920095afba30f0d5d8958f22e59de5c291 Mon Sep 17 00:00:00 2001
From: Pine Wu <octref@gmail.com>
Date: Tue, 28 Jul 2020 16:24:56 +0800
Subject: [PATCH 07/14] Update deps

---
 test/interpolation/fixture/package.json |  8 ++---
 test/interpolation/fixture/yarn.lock    | 40 ++++++++++---------------
 2 files changed, 20 insertions(+), 28 deletions(-)

diff --git a/test/interpolation/fixture/package.json b/test/interpolation/fixture/package.json
index 49c3097c1b..867b0068a3 100644
--- a/test/interpolation/fixture/package.json
+++ b/test/interpolation/fixture/package.json
@@ -1,9 +1,9 @@
 {
   "dependencies": {
     "vue": "^2.6.11",
-    "vue-class-component": "^7.0.2",
-    "vue-property-decorator": "^8.2.1",
-    "vue-router": "^3.0.6",
-    "vuex": "^3.1.0"
+    "vue-class-component": "^7.2.5",
+    "vue-property-decorator": "^9.0.0",
+    "vue-router": "^3.3.4",
+    "vuex": "^3.5.1"
   }
 }
diff --git a/test/interpolation/fixture/yarn.lock b/test/interpolation/fixture/yarn.lock
index 4a61058dc6..872a32e25b 100644
--- a/test/interpolation/fixture/yarn.lock
+++ b/test/interpolation/fixture/yarn.lock
@@ -2,35 +2,27 @@
 # yarn lockfile v1
 
 
-vue-class-component@^7.0.1:
-  version "7.1.0"
-  resolved "https://registry.yarnpkg.com/vue-class-component/-/vue-class-component-7.1.0.tgz#b33efcb10e17236d684f70b1e96f1946ec793e87"
-  integrity sha512-G9152NzUkz0i0xTfhk0Afc8vzdXxDR1pfN4dTwE72cskkgJtdXfrKBkMfGvDuxUh35U500g5Ve4xL8PEGdWeHg==
+vue-class-component@^7.2.5:
+  version "7.2.5"
+  resolved "https://registry.yarnpkg.com/vue-class-component/-/vue-class-component-7.2.5.tgz#212b3548c4fdd3314774c4adbc1c3792a40b52d0"
+  integrity sha512-0CSftHY0bDTD+4FbYkuFf6+iKDjZ4h2in2YYJDRMk5daZIjrgT9LjFHvP7Rzqy9/s1pij3zDtTSLRUjsPWMwqg==
 
-vue-class-component@^7.0.2:
-  version "7.0.2"
-  resolved "https://registry.yarnpkg.com/vue-class-component/-/vue-class-component-7.0.2.tgz#c5f35a91c0e9341532392b84d606a84911fb13bc"
-  integrity sha512-8xw/wkZI2tgHcwvkSRC1ax7GeP1CG27wKhedvOAdjdASm05VU4RijGsCYti6s6CzBioBL5BQUmntQQTCsp1wnQ==
+vue-property-decorator@^9.0.0:
+  version "9.0.0"
+  resolved "https://registry.yarnpkg.com/vue-property-decorator/-/vue-property-decorator-9.0.0.tgz#0a5f6d47d33ca62a8876108ccfa65c2c4fb7325a"
+  integrity sha512-oegTNPItuHOkW0AP1MnbdNwkmyhfsUIIXvIRHpgC18tVoEo21/i6kItyeekjMs8JgZJeuHzsaTc/DZaJFH4IWQ==
 
-vue-property-decorator@^8.2.1:
-  version "8.2.1"
-  resolved "https://registry.yarnpkg.com/vue-property-decorator/-/vue-property-decorator-8.2.1.tgz#3791662033b20d20d098cb20e86fd23842982508"
-  integrity sha512-zgtcvzGB2JpDqnIxVhTK+6m+dv3uyhYs+tL8elL+DWiXj9kDonKcPY7f1DHYX1NlnWPCj7ht0nL/i8+S1gg76Q==
-  dependencies:
-    vue "^2.6.10"
-    vue-class-component "^7.0.1"
-
-vue-router@^3.0.6:
-  version "3.0.6"
-  resolved "https://registry.yarnpkg.com/vue-router/-/vue-router-3.0.6.tgz#2e4f0f9cbb0b96d0205ab2690cfe588935136ac3"
-  integrity sha512-Ox0ciFLswtSGRTHYhGvx2L44sVbTPNS+uD2kRISuo8B39Y79rOo0Kw0hzupTmiVtftQYCZl87mwldhh2L9Aquw==
+vue-router@^3.3.4:
+  version "3.3.4"
+  resolved "https://registry.yarnpkg.com/vue-router/-/vue-router-3.3.4.tgz#4e38abc34a11c41b6c3d8244449a2e363ba6250b"
+  integrity sha512-SdKRBeoXUjaZ9R/8AyxsdTqkOfMcI5tWxPZOUX5Ie1BTL5rPSZ0O++pbiZCeYeythiZIdLEfkDiQPKIaWk5hDg==
 
 vue@^2.6.11:
   version "2.6.11"
   resolved "https://registry.yarnpkg.com/vue/-/vue-2.6.11.tgz#76594d877d4b12234406e84e35275c6d514125c5"
   integrity sha512-VfPwgcGABbGAue9+sfrD4PuwFar7gPb1yl1UK1MwXoQPAw0BKSqWfoYCT/ThFrdEVWoI51dBuyCoiNU9bZDZxQ==
 
-vuex@^3.1.0:
-  version "3.1.0"
-  resolved "https://registry.yarnpkg.com/vuex/-/vuex-3.1.0.tgz#634b81515cf0cfe976bd1ffe9601755e51f843b9"
-  integrity sha512-mdHeHT/7u4BncpUZMlxNaIdcN/HIt1GsGG5LKByArvYG/v6DvHcOxvDCts+7SRdCoIRGllK8IMZvQtQXLppDYg==
+vuex@^3.5.1:
+  version "3.5.1"
+  resolved "https://registry.yarnpkg.com/vuex/-/vuex-3.5.1.tgz#f1b8dcea649bc25254cf4f4358081dbf5da18b3d"
+  integrity sha512-w7oJzmHQs0FM9LXodfskhw9wgKBiaB+totOdb8sNzbTB2KDCEEwEs29NzBZFh/lmEK1t5tDmM1vtsO7ubG1DFw==

From 74374b1bd6499c8834ffa7fb731eaec8d1d03fdc Mon Sep 17 00:00:00 2001
From: yoyo930021 <yoyo930021@gmail.com>
Date: Sat, 1 Aug 2020 14:54:26 +0800
Subject: [PATCH 08/14] Fix the tests and align basic tests

---
 .../{ => features}/completion/class.test.ts   | 69 ++++++++++++-------
 .../completion/property.test.ts               | 49 ++++++++-----
 .../fixture/completion/BasicClass.vue         |  8 +++
 .../fixture/completion/BasicPropertyClass.vue |  8 +++
 .../fixture/completion/ParentClass.vue        |  1 +
 .../completion/ParentPropertyClass.vue        |  1 +
 6 files changed, 94 insertions(+), 42 deletions(-)
 rename test/interpolation/{ => features}/completion/class.test.ts (69%)
 rename test/interpolation/{ => features}/completion/property.test.ts (75%)

diff --git a/test/interpolation/completion/class.test.ts b/test/interpolation/features/completion/class.test.ts
similarity index 69%
rename from test/interpolation/completion/class.test.ts
rename to test/interpolation/features/completion/class.test.ts
index 7037b06f16..75d1d95139 100644
--- a/test/interpolation/completion/class.test.ts
+++ b/test/interpolation/features/completion/class.test.ts
@@ -1,5 +1,4 @@
-import { activateLS, showFile, sleep, FILE_LOAD_SLEEP_TIME } from '../../lsp/helper';
-import { position, getDocUri } from '../util';
+import { position, getDocUri } from '../../util';
 import { testCompletion, testNoSuchCompletion } from './helper';
 import { CompletionItem, CompletionItemKind, MarkdownString } from 'vscode';
 
@@ -7,29 +6,24 @@ describe('Should autocomplete interpolation for <template> in class component',
   const templateDocUri = getDocUri('completion/BasicClass.vue');
   const parentTemplateDocUri = getDocUri('completion/ParentClass.vue');
 
-  before('activate', async () => {
-    await activateLS();
-    await showFile(templateDocUri);
-    await sleep(FILE_LOAD_SLEEP_TIME);
-    await sleep(FILE_LOAD_SLEEP_TIME);
-  });
-
   const defaultList: CompletionItem[] = [
-    {
-      label: 'foo',
-      documentation: new MarkdownString('My foo').appendCodeblock(
-        `foo: {
-  type: Boolean,
-  default: false
-}`,
-        'js'
-      ),
-      kind: CompletionItemKind.Property
-    },
+    // Typescript can't typing when `@Component({ props: { foo: String } })`.
+    // Because decorator cant affect return type.
+    //     {
+    //       label: 'foo',
+    //       documentation: new MarkdownString('My foo').appendCodeblock(
+    //         `foo: {
+    //   type: Boolean,
+    //   default: false
+    // }`,
+    //         'js'
+    //       ),
+    //       kind: CompletionItemKind.Field
+    //     },
     {
       label: 'msg',
       documentation: new MarkdownString('My msg').appendCodeblock(`msg = 'Vetur means "Winter" in icelandic.'`, 'js'),
-      kind: CompletionItemKind.Property
+      kind: CompletionItemKind.Field
     },
     {
       label: 'count',
@@ -39,7 +33,7 @@ describe('Should autocomplete interpolation for <template> in class component',
 }`,
         'js'
       ),
-      kind: CompletionItemKind.Property
+      kind: CompletionItemKind.Field
     },
     {
       label: 'hello',
@@ -50,7 +44,7 @@ describe('Should autocomplete interpolation for <template> in class component',
         'js'
       ),
 
-      kind: CompletionItemKind.Method
+      kind: CompletionItemKind.Function
     }
   ];
 
@@ -59,10 +53,20 @@ describe('Should autocomplete interpolation for <template> in class component',
       await testCompletion(templateDocUri, position(2, 7), defaultList);
     });
 
+    it('completes an object property', async () => {
+      await testCompletion(templateDocUri, position(3, 11), [
+        {
+          label: 'msg',
+          kind: CompletionItemKind.Field
+        }
+      ]);
+    });
+
     it(`completes child component tag`, async () => {
-      await testCompletion(parentTemplateDocUri, position(4, 5), [
+      await testCompletion(parentTemplateDocUri, position(5, 5), [
         {
           label: 'basic-class',
+          kind: CompletionItemKind.Property,
           documentationStart: 'My basic tag\n```js\n@Component('
         }
       ]);
@@ -72,6 +76,23 @@ describe('Should autocomplete interpolation for <template> in class component',
       await testCompletion(parentTemplateDocUri, position(2, 18), [
         {
           label: 'foo',
+          kind: CompletionItemKind.Value,
+          documentation: new MarkdownString('My foo').appendCodeblock(
+            `foo: {
+  type: Boolean,
+  default: false
+}`,
+            'js'
+          )
+        }
+      ]);
+    });
+
+    it(`completes child component's props when camel case component name`, async () => {
+      await testCompletion(parentTemplateDocUri, position(4, 16), [
+        {
+          label: 'foo',
+          kind: CompletionItemKind.Value,
           documentation: new MarkdownString('My foo').appendCodeblock(
             `foo: {
   type: Boolean,
diff --git a/test/interpolation/completion/property.test.ts b/test/interpolation/features/completion/property.test.ts
similarity index 75%
rename from test/interpolation/completion/property.test.ts
rename to test/interpolation/features/completion/property.test.ts
index 8dd15df696..7243d18ef0 100644
--- a/test/interpolation/completion/property.test.ts
+++ b/test/interpolation/features/completion/property.test.ts
@@ -1,5 +1,4 @@
-import { activateLS, showFile, sleep, FILE_LOAD_SLEEP_TIME } from '../../lsp/helper';
-import { position, getDocUri } from '../util';
+import { position, getDocUri } from '../../util';
 import { testCompletion, testNoSuchCompletion } from './helper';
 import { CompletionItem, CompletionItemKind, MarkdownString } from 'vscode';
 
@@ -7,26 +6,16 @@ describe('Should autocomplete interpolation for <template> in property class com
   const templateDocUri = getDocUri('completion/BasicPropertyClass.vue');
   const parentTemplateDocUri = getDocUri('completion/ParentPropertyClass.vue');
 
-  before('activate', async () => {
-    await activateLS();
-    await showFile(templateDocUri);
-    await sleep(FILE_LOAD_SLEEP_TIME);
-    await sleep(FILE_LOAD_SLEEP_TIME);
-  });
-
   const defaultList: CompletionItem[] = [
     {
       label: 'foo',
-      documentation: new MarkdownString('My foo').appendCodeblock(
-        `@Prop({ type: Boolean, default: false }) foo`,
-        'js'
-      ),
-      kind: CompletionItemKind.Property
+      documentation: new MarkdownString('My foo').appendCodeblock(`@Prop({ type: Boolean, default: false }) foo`, 'js'),
+      kind: CompletionItemKind.Field
     },
     {
       label: 'msg',
       documentation: new MarkdownString('My msg').appendCodeblock(`msg = 'Vetur means "Winter" in icelandic.'`, 'js'),
-      kind: CompletionItemKind.Property
+      kind: CompletionItemKind.Field
     },
     {
       label: 'count',
@@ -36,7 +25,7 @@ describe('Should autocomplete interpolation for <template> in property class com
 }`,
         'js'
       ),
-      kind: CompletionItemKind.Property
+      kind: CompletionItemKind.Field
     },
     {
       label: 'hello',
@@ -47,7 +36,7 @@ describe('Should autocomplete interpolation for <template> in property class com
         'js'
       ),
 
-      kind: CompletionItemKind.Method
+      kind: CompletionItemKind.Function
     }
   ];
 
@@ -56,10 +45,20 @@ describe('Should autocomplete interpolation for <template> in property class com
       await testCompletion(templateDocUri, position(2, 7), defaultList);
     });
 
+    it('completes an object property', async () => {
+      await testCompletion(templateDocUri, position(3, 11), [
+        {
+          label: 'msg',
+          kind: CompletionItemKind.Field
+        }
+      ]);
+    });
+
     it(`completes child component tag`, async () => {
-      await testCompletion(parentTemplateDocUri, position(4, 5), [
+      await testCompletion(parentTemplateDocUri, position(5, 5), [
         {
           label: 'basic-property-class',
+          kind: CompletionItemKind.Property,
           documentationStart: 'My basic tag\n```js\n@Component('
         }
       ]);
@@ -69,6 +68,20 @@ describe('Should autocomplete interpolation for <template> in property class com
       await testCompletion(parentTemplateDocUri, position(2, 27), [
         {
           label: 'foo',
+          kind: CompletionItemKind.Value,
+          documentation: new MarkdownString('My foo').appendCodeblock(
+            `@Prop({ type: Boolean, default: false }) foo`,
+            'js'
+          )
+        }
+      ]);
+    });
+
+    it(`completes child component's props when camel case component name`, async () => {
+      await testCompletion(parentTemplateDocUri, position(4, 24), [
+        {
+          label: 'foo',
+          kind: CompletionItemKind.Value,
           documentation: new MarkdownString('My foo').appendCodeblock(
             `@Prop({ type: Boolean, default: false }) foo`,
             'js'
diff --git a/test/interpolation/fixture/completion/BasicClass.vue b/test/interpolation/fixture/completion/BasicClass.vue
index 629d74923f..0aa9256ad0 100644
--- a/test/interpolation/fixture/completion/BasicClass.vue
+++ b/test/interpolation/fixture/completion/BasicClass.vue
@@ -1,6 +1,7 @@
 <template>
   <div>
     {{  }}
+    {{ obj. }}
   </div>
 </template>
 
@@ -28,6 +29,13 @@ export default class BasicClass extends Vue {
    */
   msg = 'Vetur means "Winter" in icelandic.'
 
+  /**
+   * My obj
+   */
+  obj = {
+    msg: 'Object message.'
+  }
+
   /**
    * My count
    */
diff --git a/test/interpolation/fixture/completion/BasicPropertyClass.vue b/test/interpolation/fixture/completion/BasicPropertyClass.vue
index 66408c7100..08077f4ee9 100644
--- a/test/interpolation/fixture/completion/BasicPropertyClass.vue
+++ b/test/interpolation/fixture/completion/BasicPropertyClass.vue
@@ -1,6 +1,7 @@
 <template>
   <div>
     {{  }}
+    {{ obj. }}
   </div>
 </template>
 
@@ -23,6 +24,13 @@ export default class BasicPropertyClass extends Vue {
    */
   msg = 'Vetur means "Winter" in icelandic.'
 
+  /**
+   * My obj
+   */
+  obj = {
+    msg: 'Object message.'
+  }
+
   /**
    * My count
    */
diff --git a/test/interpolation/fixture/completion/ParentClass.vue b/test/interpolation/fixture/completion/ParentClass.vue
index eed414afd4..c8dc081dd2 100644
--- a/test/interpolation/fixture/completion/ParentClass.vue
+++ b/test/interpolation/fixture/completion/ParentClass.vue
@@ -2,6 +2,7 @@
   <div>
     <basic-class :></basic-class>
     <basic-class v-if="" @click="" :foo=""></basic-class>
+    <BasicClass  />
     <
   </div>
 </template>
diff --git a/test/interpolation/fixture/completion/ParentPropertyClass.vue b/test/interpolation/fixture/completion/ParentPropertyClass.vue
index f0756bcc13..568f05bc6c 100644
--- a/test/interpolation/fixture/completion/ParentPropertyClass.vue
+++ b/test/interpolation/fixture/completion/ParentPropertyClass.vue
@@ -2,6 +2,7 @@
   <div>
     <basic-property-class :></basic-property-class>
     <basic-property-class v-if="" @click="" :foo=""></basic-property-class>
+    <BasicPropertyClass  />
     <
   </div>
 </template>

From 0f2a43a743a266d98bb87d720fc940b3c038bb5c Mon Sep 17 00:00:00 2001
From: Pine Wu <octref@gmail.com>
Date: Mon, 10 Aug 2020 13:11:34 +0800
Subject: [PATCH 09/14] Fix compilation

---
 .../features/completion/class.test.ts         | 27 ++++++++++---------
 .../features/completion/property.test.ts      |  5 ++--
 2 files changed, 17 insertions(+), 15 deletions(-)

diff --git a/test/interpolation/features/completion/class.test.ts b/test/interpolation/features/completion/class.test.ts
index 75d1d95139..d2adacc3f6 100644
--- a/test/interpolation/features/completion/class.test.ts
+++ b/test/interpolation/features/completion/class.test.ts
@@ -1,6 +1,7 @@
-import { position, getDocUri } from '../../util';
-import { testCompletion, testNoSuchCompletion } from './helper';
 import { CompletionItem, CompletionItemKind, MarkdownString } from 'vscode';
+import { position } from '../../../util';
+import { getDocUri } from '../../path';
+import { testCompletion, testNoSuchCompletion } from '../../../completionHelper';
 
 describe('Should autocomplete interpolation for <template> in class component', () => {
   const templateDocUri = getDocUri('completion/BasicClass.vue');
@@ -9,17 +10,17 @@ describe('Should autocomplete interpolation for <template> in class component',
   const defaultList: CompletionItem[] = [
     // Typescript can't typing when `@Component({ props: { foo: String } })`.
     // Because decorator cant affect return type.
-    //     {
-    //       label: 'foo',
-    //       documentation: new MarkdownString('My foo').appendCodeblock(
-    //         `foo: {
-    //   type: Boolean,
-    //   default: false
-    // }`,
-    //         'js'
-    //       ),
-    //       kind: CompletionItemKind.Field
-    //     },
+    // {
+    //   label: 'foo',
+    //   documentation: new MarkdownString('My foo').appendCodeblock(
+    //     `foo: {
+    //       type: Boolean,
+    //       default: false
+    //     }`,
+    //     'js'
+    //   ),
+    //   kind: CompletionItemKind.Field
+    // }
     {
       label: 'msg',
       documentation: new MarkdownString('My msg').appendCodeblock(`msg = 'Vetur means "Winter" in icelandic.'`, 'js'),
diff --git a/test/interpolation/features/completion/property.test.ts b/test/interpolation/features/completion/property.test.ts
index 7243d18ef0..5a88e815d8 100644
--- a/test/interpolation/features/completion/property.test.ts
+++ b/test/interpolation/features/completion/property.test.ts
@@ -1,6 +1,7 @@
-import { position, getDocUri } from '../../util';
-import { testCompletion, testNoSuchCompletion } from './helper';
 import { CompletionItem, CompletionItemKind, MarkdownString } from 'vscode';
+import { getDocUri } from '../../path';
+import { testCompletion, testNoSuchCompletion } from '../../../completionHelper';
+import { position } from '../../../util';
 
 describe('Should autocomplete interpolation for <template> in property class component', () => {
   const templateDocUri = getDocUri('completion/BasicPropertyClass.vue');

From 79a1efd2607a0423d69159a9760d85f45a5b9a38 Mon Sep 17 00:00:00 2001
From: yoyo930021 <yoyo930021@gmail.com>
Date: Mon, 10 Aug 2020 13:22:06 +0800
Subject: [PATCH 10/14] Pick a1c5604

---
 server/src/modes/script/componentInfo.ts | 20 ++++++++------------
 1 file changed, 8 insertions(+), 12 deletions(-)

diff --git a/server/src/modes/script/componentInfo.ts b/server/src/modes/script/componentInfo.ts
index 2539254d47..a3758026b8 100644
--- a/server/src/modes/script/componentInfo.ts
+++ b/server/src/modes/script/componentInfo.ts
@@ -81,13 +81,9 @@ export function analyzeDefaultExportExpr(
   };
 }
 
-export function getDefaultExportNode(
-  tsModule: T_TypeScript,
-  sourceFile: ts.SourceFile
-): ts.Node | undefined {
-  const exportStmts = sourceFile.statements.filter(st =>
-    st.kind === tsModule.SyntaxKind.ExportAssignment ||
-    st.kind === tsModule.SyntaxKind.ClassDeclaration
+export function getDefaultExportNode(tsModule: T_TypeScript, sourceFile: ts.SourceFile): ts.Node | undefined {
+  const exportStmts = sourceFile.statements.filter(
+    st => st.kind === tsModule.SyntaxKind.ExportAssignment || st.kind === tsModule.SyntaxKind.ClassDeclaration
   );
   if (exportStmts.length === 0) {
     return undefined;
@@ -143,7 +139,10 @@ function getProps(tsModule: T_TypeScript, defaultExportType: ts.Type, checker: t
         .filter(expr => expr.kind === tsModule.SyntaxKind.StringLiteral)
         .map(expr => {
           return {
-            name: (expr as ts.StringLiteral).text
+            name: (expr as ts.StringLiteral).text,
+            documentation: `\`\`\`js\n${formatJSLikeDocumentation(
+              propsDeclaration.parent.getFullText().trim()
+            )}\n\`\`\`\n`
           };
         });
     }
@@ -380,10 +379,7 @@ function getMethods(
   return result.length === 0 ? undefined : result;
 }
 
-function getNodeFromExportNode(
-  tsModule: T_TypeScript,
-  exportExpr: ts.Node
-): ts.Node | undefined {
+function getNodeFromExportNode(tsModule: T_TypeScript, exportExpr: ts.Node): ts.Node | undefined {
   switch (exportExpr.kind) {
     case tsModule.SyntaxKind.CallExpression:
       // Vue.extend or synthetic __vueEditorBridge

From c123476b2146546ca5a8b4c3d4335fa511dd180c Mon Sep 17 00:00:00 2001
From: Pine Wu <octref@gmail.com>
Date: Mon, 10 Aug 2020 13:37:50 +0800
Subject: [PATCH 11/14] Fix test errors

---
 test/interpolation/features/completion/class.test.ts    | 4 ++--
 test/interpolation/features/completion/property.test.ts | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/test/interpolation/features/completion/class.test.ts b/test/interpolation/features/completion/class.test.ts
index d2adacc3f6..99af4bf55f 100644
--- a/test/interpolation/features/completion/class.test.ts
+++ b/test/interpolation/features/completion/class.test.ts
@@ -76,7 +76,7 @@ describe('Should autocomplete interpolation for <template> in class component',
     it(`completes child component's props`, async () => {
       await testCompletion(parentTemplateDocUri, position(2, 18), [
         {
-          label: 'foo',
+          label: ':foo',
           kind: CompletionItemKind.Value,
           documentation: new MarkdownString('My foo').appendCodeblock(
             `foo: {
@@ -92,7 +92,7 @@ describe('Should autocomplete interpolation for <template> in class component',
     it(`completes child component's props when camel case component name`, async () => {
       await testCompletion(parentTemplateDocUri, position(4, 16), [
         {
-          label: 'foo',
+          label: ':foo',
           kind: CompletionItemKind.Value,
           documentation: new MarkdownString('My foo').appendCodeblock(
             `foo: {
diff --git a/test/interpolation/features/completion/property.test.ts b/test/interpolation/features/completion/property.test.ts
index 5a88e815d8..5d7f0340bb 100644
--- a/test/interpolation/features/completion/property.test.ts
+++ b/test/interpolation/features/completion/property.test.ts
@@ -68,7 +68,7 @@ describe('Should autocomplete interpolation for <template> in property class com
     it(`completes child component's props`, async () => {
       await testCompletion(parentTemplateDocUri, position(2, 27), [
         {
-          label: 'foo',
+          label: ':foo',
           kind: CompletionItemKind.Value,
           documentation: new MarkdownString('My foo').appendCodeblock(
             `@Prop({ type: Boolean, default: false }) foo`,
@@ -81,7 +81,7 @@ describe('Should autocomplete interpolation for <template> in property class com
     it(`completes child component's props when camel case component name`, async () => {
       await testCompletion(parentTemplateDocUri, position(4, 24), [
         {
-          label: 'foo',
+          label: ':foo',
           kind: CompletionItemKind.Value,
           documentation: new MarkdownString('My foo').appendCodeblock(
             `@Prop({ type: Boolean, default: false }) foo`,

From 44ff51cec55d0a7ea3171c730230138cc6e7f0a3 Mon Sep 17 00:00:00 2001
From: yoyo930021 <yoyo930021@gmail.com>
Date: Tue, 11 Aug 2020 13:27:47 +0800
Subject: [PATCH 12/14] Fix crash when no aliased symbol

---
 server/src/modes/script/childComponents.ts | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/server/src/modes/script/childComponents.ts b/server/src/modes/script/childComponents.ts
index 5540ed1b68..c241bb65f9 100644
--- a/server/src/modes/script/childComponents.ts
+++ b/server/src/modes/script/childComponents.ts
@@ -74,7 +74,10 @@ export function getChildComponents(
 
       if (objectLiteralSymbol.flags & tsModule.SymbolFlags.Alias) {
         const definitionSymbol = checker.getAliasedSymbol(objectLiteralSymbol);
-        const sourceFile = definitionSymbol.valueDeclaration.getSourceFile()
+        if (!definitionSymbol.valueDeclaration) {
+          return;
+        }
+        const sourceFile = definitionSymbol.valueDeclaration.getSourceFile();
         const defaultExportNode = getDefaultExportNode(
           tsModule,
           sourceFile

From e0603163cfecd3f8307249d29d0352a8bff1c18f Mon Sep 17 00:00:00 2001
From: Pine Wu <octref@gmail.com>
Date: Fri, 14 Aug 2020 11:14:18 +0800
Subject: [PATCH 13/14] Clean up

---
 CHANGELOG.md                                  |  1 +
 test/definitionHelper.ts                      | 16 ++++++++++++++
 .../features/completion/class.test.ts         |  9 ++++----
 .../features/completion/property.test.ts      |  4 ++--
 .../features/definition/basic.test.ts         | 17 +-------------
 .../features/definition/class.test.ts         | 22 +++++++++++++++++++
 .../diagnostics/propsValidation.test.ts       |  2 +-
 .../Child.vue}                                |  0
 .../Parent.vue}                               |  2 +-
 .../Child.vue}                                |  3 +++
 .../Parent.vue}                               |  4 ++--
 .../definition/classComponent/Child.vue       | 11 ++++++++++
 .../definition/classComponent/Parent.vue      | 19 ++++++++++++++++
 test/lsp/features/definition/basic.test.ts    | 17 +-------------
 14 files changed, 85 insertions(+), 42 deletions(-)
 create mode 100644 test/definitionHelper.ts
 create mode 100644 test/interpolation/features/definition/class.test.ts
 rename test/interpolation/fixture/completion/{BasicClass.vue => classComponent/Child.vue} (100%)
 rename test/interpolation/fixture/completion/{ParentClass.vue => classComponent/Parent.vue} (94%)
 rename test/interpolation/fixture/completion/{BasicPropertyClass.vue => propertyDecorator/Child.vue} (94%)
 rename test/interpolation/fixture/completion/{ParentPropertyClass.vue => propertyDecorator/Parent.vue} (85%)
 create mode 100644 test/interpolation/fixture/definition/classComponent/Child.vue
 create mode 100644 test/interpolation/fixture/definition/classComponent/Parent.vue

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 76cc14e166..715d82d7ca 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -11,6 +11,7 @@
 - Linkify all vue/vue-router tags to their API doc. #2133.
 - Component Data - `type: 'boolean'` should trigger completion without `=""`. #2127.
 - Component Data doesn't work if it comes from devDependencies. #2132.
+- 🙌 Add support for analyzing vue-class-component and vue-property-decorator. Thanks to contribution from [@yoyo930021](https://github.com/yoyo930021). #864, #1105 and #1323.
 
 ### 0.26.1 | 2020-08-07 | [VSIX](https://marketplace.visualstudio.com/_apis/public/gallery/publishers/octref/vsextensions/vetur/0.26.1/vspackage)
 
diff --git a/test/definitionHelper.ts b/test/definitionHelper.ts
new file mode 100644
index 0000000000..0ec1db0e70
--- /dev/null
+++ b/test/definitionHelper.ts
@@ -0,0 +1,16 @@
+import * as assert from 'assert';
+import * as vscode from 'vscode';
+import { showFile } from './editorHelper';
+
+export async function testDefinition(docUri: vscode.Uri, position: vscode.Position, expectedLocation: vscode.Location) {
+  await showFile(docUri);
+
+  const result = (await vscode.commands.executeCommand(
+    'vscode.executeDefinitionProvider',
+    docUri,
+    position
+  )) as vscode.Location[];
+
+  assert.ok(result[0].range.isEqual(expectedLocation.range));
+  assert.equal(result[0].uri.fsPath, expectedLocation.uri.fsPath);
+}
diff --git a/test/interpolation/features/completion/class.test.ts b/test/interpolation/features/completion/class.test.ts
index 99af4bf55f..d275067b12 100644
--- a/test/interpolation/features/completion/class.test.ts
+++ b/test/interpolation/features/completion/class.test.ts
@@ -4,12 +4,13 @@ import { getDocUri } from '../../path';
 import { testCompletion, testNoSuchCompletion } from '../../../completionHelper';
 
 describe('Should autocomplete interpolation for <template> in class component', () => {
-  const templateDocUri = getDocUri('completion/BasicClass.vue');
-  const parentTemplateDocUri = getDocUri('completion/ParentClass.vue');
+  const templateDocUri = getDocUri('completion/classComponent/Child.vue');
+  const parentTemplateDocUri = getDocUri('completion/classComponent/Parent.vue');
 
   const defaultList: CompletionItem[] = [
-    // Typescript can't typing when `@Component({ props: { foo: String } })`.
-    // Because decorator cant affect return type.
+    // Typescript can't type the return type with `@Component({ props: { foo: String } })`.
+    // Because decorator can't affect return type.
+    // https://github.com/vuejs/vue-class-component/issues/360#issuecomment-549148795
     // {
     //   label: 'foo',
     //   documentation: new MarkdownString('My foo').appendCodeblock(
diff --git a/test/interpolation/features/completion/property.test.ts b/test/interpolation/features/completion/property.test.ts
index 5d7f0340bb..5c4059b9b3 100644
--- a/test/interpolation/features/completion/property.test.ts
+++ b/test/interpolation/features/completion/property.test.ts
@@ -4,8 +4,8 @@ import { testCompletion, testNoSuchCompletion } from '../../../completionHelper'
 import { position } from '../../../util';
 
 describe('Should autocomplete interpolation for <template> in property class component', () => {
-  const templateDocUri = getDocUri('completion/BasicPropertyClass.vue');
-  const parentTemplateDocUri = getDocUri('completion/ParentPropertyClass.vue');
+  const templateDocUri = getDocUri('completion/propertyDecorator/Child.vue');
+  const parentTemplateDocUri = getDocUri('completion/propertyDecorator/Parent.vue');
 
   const defaultList: CompletionItem[] = [
     {
diff --git a/test/interpolation/features/definition/basic.test.ts b/test/interpolation/features/definition/basic.test.ts
index da7d64e508..c17f1ea0b4 100644
--- a/test/interpolation/features/definition/basic.test.ts
+++ b/test/interpolation/features/definition/basic.test.ts
@@ -1,8 +1,6 @@
-import * as assert from 'assert';
-import * as vscode from 'vscode';
-import { showFile } from '../../../editorHelper';
 import { position, sameLineLocation } from '../../../util';
 import { getDocUri } from '../../path';
+import { testDefinition } from '../../../definitionHelper';
 
 describe('Should find definition', () => {
   const docUri = getDocUri('definition/Basic.vue');
@@ -22,16 +20,3 @@ describe('Should find definition', () => {
     await testDefinition(docUri, position(4, 5), sameLineLocation(tagUri, 0, 0, 0));
   });
 });
-
-async function testDefinition(docUri: vscode.Uri, position: vscode.Position, expectedLocation: vscode.Location) {
-  await showFile(docUri);
-
-  const result = (await vscode.commands.executeCommand(
-    'vscode.executeDefinitionProvider',
-    docUri,
-    position
-  )) as vscode.Location[];
-
-  assert.ok(result[0].range.isEqual(expectedLocation.range));
-  assert.equal(result[0].uri.fsPath, expectedLocation.uri.fsPath);
-}
diff --git a/test/interpolation/features/definition/class.test.ts b/test/interpolation/features/definition/class.test.ts
new file mode 100644
index 0000000000..0d5f21c2e0
--- /dev/null
+++ b/test/interpolation/features/definition/class.test.ts
@@ -0,0 +1,22 @@
+import { position, sameLineLocation } from '../../../util';
+import { getDocUri } from '../../path';
+import { testDefinition } from '../../../definitionHelper';
+
+describe('Should find definition for vue-class-component components', () => {
+  const parentUri = getDocUri('definition/classComponent/Parent.vue');
+
+  it('finds definition for opening tag in <child></child>', async () => {
+    const tagUri = getDocUri('definition/classComponent/Child.vue');
+    await testDefinition(parentUri, position(2, 5), sameLineLocation(tagUri, 0, 0, 0));
+  });
+
+  it('finds definition for closing tag in <child></child>', async () => {
+    const tagUri = getDocUri('definition/classComponent/Child.vue');
+    await testDefinition(parentUri, position(2, 13), sameLineLocation(tagUri, 0, 0, 0));
+  });
+
+  it('finds definition for self-closing tag <child />', async () => {
+    const tagUri = getDocUri('definition/classComponent/Child.vue');
+    await testDefinition(parentUri, position(3, 5), sameLineLocation(tagUri, 0, 0, 0));
+  });
+});
diff --git a/test/interpolation/features/diagnostics/propsValidation.test.ts b/test/interpolation/features/diagnostics/propsValidation.test.ts
index ef1bbdb273..d0b0923b84 100644
--- a/test/interpolation/features/diagnostics/propsValidation.test.ts
+++ b/test/interpolation/features/diagnostics/propsValidation.test.ts
@@ -6,7 +6,7 @@ import { sameLineRange } from '../../../util';
 describe('Should find common diagnostics for all regions', () => {
   const parentUri = getDocUri('diagnostics/propsValidation/parent.vue');
 
-  it('ZZ shows errors for passing wrong props to child component', async () => {
+  it('shows errors for passing wrong props to child component', async () => {
     const expectedDiagnostics: vscode.Diagnostic[] = [
       {
         message: '<child> misses props: foo, bar, b-az',
diff --git a/test/interpolation/fixture/completion/BasicClass.vue b/test/interpolation/fixture/completion/classComponent/Child.vue
similarity index 100%
rename from test/interpolation/fixture/completion/BasicClass.vue
rename to test/interpolation/fixture/completion/classComponent/Child.vue
diff --git a/test/interpolation/fixture/completion/ParentClass.vue b/test/interpolation/fixture/completion/classComponent/Parent.vue
similarity index 94%
rename from test/interpolation/fixture/completion/ParentClass.vue
rename to test/interpolation/fixture/completion/classComponent/Parent.vue
index c8dc081dd2..206ca9eccc 100644
--- a/test/interpolation/fixture/completion/ParentClass.vue
+++ b/test/interpolation/fixture/completion/classComponent/Parent.vue
@@ -9,7 +9,7 @@
 
 <script>
 import Vue from 'vue'
-import BasicClass from './BasicClass.vue'
+import BasicClass from './Child.vue'
 import Component from 'vue-class-component'
 
 @Component({
diff --git a/test/interpolation/fixture/completion/BasicPropertyClass.vue b/test/interpolation/fixture/completion/propertyDecorator/Child.vue
similarity index 94%
rename from test/interpolation/fixture/completion/BasicPropertyClass.vue
rename to test/interpolation/fixture/completion/propertyDecorator/Child.vue
index 08077f4ee9..b59f16a6dc 100644
--- a/test/interpolation/fixture/completion/BasicPropertyClass.vue
+++ b/test/interpolation/fixture/completion/propertyDecorator/Child.vue
@@ -28,6 +28,9 @@ export default class BasicPropertyClass extends Vue {
    * My obj
    */
   obj = {
+    /**
+     * Obj message
+     */
     msg: 'Object message.'
   }
 
diff --git a/test/interpolation/fixture/completion/ParentPropertyClass.vue b/test/interpolation/fixture/completion/propertyDecorator/Parent.vue
similarity index 85%
rename from test/interpolation/fixture/completion/ParentPropertyClass.vue
rename to test/interpolation/fixture/completion/propertyDecorator/Parent.vue
index 568f05bc6c..51f70b8dd1 100644
--- a/test/interpolation/fixture/completion/ParentPropertyClass.vue
+++ b/test/interpolation/fixture/completion/propertyDecorator/Parent.vue
@@ -1,6 +1,6 @@
 <template>
   <div>
-    <basic-property-class :></basic-property-class>
+    <basic-property-class :foo=""></basic-property-class>
     <basic-property-class v-if="" @click="" :foo=""></basic-property-class>
     <BasicPropertyClass  />
     <
@@ -9,7 +9,7 @@
 
 <script>
 import Vue from 'vue'
-import BasicPropertyClass from './BasicPropertyClass.vue'
+import BasicPropertyClass from './Child.vue'
 import { Prop, Component } from 'vue-property-decorator'
 
 @Component({
diff --git a/test/interpolation/fixture/definition/classComponent/Child.vue b/test/interpolation/fixture/definition/classComponent/Child.vue
new file mode 100644
index 0000000000..7093139af5
--- /dev/null
+++ b/test/interpolation/fixture/definition/classComponent/Child.vue
@@ -0,0 +1,11 @@
+<template>
+  <div></div>
+</template>
+
+<script>
+import Vue from 'vue'
+import Component from 'vue-class-component'
+
+@Component({})
+export default class BasicClass extends Vue {}
+</script>
diff --git a/test/interpolation/fixture/definition/classComponent/Parent.vue b/test/interpolation/fixture/definition/classComponent/Parent.vue
new file mode 100644
index 0000000000..4f9b6791c6
--- /dev/null
+++ b/test/interpolation/fixture/definition/classComponent/Parent.vue
@@ -0,0 +1,19 @@
+<template>
+  <div>
+    <child></child>
+    <child />
+  </div>
+</template>
+
+<script>
+import Vue from 'vue'
+import Child from './Child.vue'
+import Component from 'vue-class-component'
+
+@Component({
+  components: {
+    Child
+  },
+})
+export default class ParentClass extends Vue {}
+</script>
diff --git a/test/lsp/features/definition/basic.test.ts b/test/lsp/features/definition/basic.test.ts
index 5cf3dec136..25950563cb 100644
--- a/test/lsp/features/definition/basic.test.ts
+++ b/test/lsp/features/definition/basic.test.ts
@@ -1,6 +1,4 @@
-import * as assert from 'assert';
-import * as vscode from 'vscode';
-import { showFile } from '../../../editorHelper';
+import { testDefinition } from '../../../definitionHelper';
 import { location, position, sameLineLocation } from '../../../util';
 import { getDocUri } from '../../path';
 
@@ -26,16 +24,3 @@ describe('Should find definition', () => {
     await testDefinition(docUri, position(17, 7), location(itemUri, 5, 0, 7, 1));
   });
 });
-
-async function testDefinition(docUri: vscode.Uri, position: vscode.Position, expectedLocation: vscode.Location) {
-  await showFile(docUri);
-
-  const result = (await vscode.commands.executeCommand(
-    'vscode.executeDefinitionProvider',
-    docUri,
-    position
-  )) as vscode.Location[];
-
-  assert.ok(result[0].range.isEqual(expectedLocation.range));
-  assert.equal(result[0].uri.fsPath, expectedLocation.uri.fsPath);
-}

From 7ea9767c5188de610a81b24637099231847f802b Mon Sep 17 00:00:00 2001
From: Pine Wu <octref@gmail.com>
Date: Fri, 14 Aug 2020 11:49:52 +0800
Subject: [PATCH 14/14] More clean up

---
 server/src/modes/script/childComponents.ts | 15 +++++++-------
 server/src/modes/script/componentInfo.ts   | 24 +++++++++++-----------
 2 files changed, 19 insertions(+), 20 deletions(-)

diff --git a/server/src/modes/script/childComponents.ts b/server/src/modes/script/childComponents.ts
index c241bb65f9..e0ef7d075d 100644
--- a/server/src/modes/script/childComponents.ts
+++ b/server/src/modes/script/childComponents.ts
@@ -26,17 +26,19 @@ export function getChildComponents(
   checker: ts.TypeChecker,
   tagCasing = 'kebab'
 ): InternalChildComponent[] | undefined {
-  let type = defaultExportType;
-  if (isClassType(tsModule, type)) {
+  let componentsSymbol: ts.Symbol | undefined;
+
+  if (!isClassType(tsModule, defaultExportType)) {
+    componentsSymbol = checker.getPropertyOfType(defaultExportType, 'components');
+  } else {
     // get decorator argument type when class
     const classDecoratorArgumentType = getClassDecoratorArgumentType(tsModule, defaultExportType, checker);
     if (!classDecoratorArgumentType) {
       return undefined;
     }
-    type = classDecoratorArgumentType;
+    componentsSymbol = checker.getPropertyOfType(classDecoratorArgumentType, 'components');
   }
 
-  const componentsSymbol = checker.getPropertyOfType(type, 'components');
   if (!componentsSymbol || !componentsSymbol.valueDeclaration) {
     return undefined;
   }
@@ -78,10 +80,7 @@ export function getChildComponents(
           return;
         }
         const sourceFile = definitionSymbol.valueDeclaration.getSourceFile();
-        const defaultExportNode = getDefaultExportNode(
-          tsModule,
-          sourceFile
-        );
+        const defaultExportNode = getDefaultExportNode(tsModule, sourceFile);
         if (!defaultExportNode) {
           return;
         }
diff --git a/server/src/modes/script/componentInfo.ts b/server/src/modes/script/componentInfo.ts
index a3758026b8..c38445ab75 100644
--- a/server/src/modes/script/componentInfo.ts
+++ b/server/src/modes/script/componentInfo.ts
@@ -61,10 +61,10 @@ export function getComponentInfo(
 
 export function analyzeDefaultExportExpr(
   tsModule: T_TypeScript,
-  defaultExport: ts.Node,
+  defaultExportNode: ts.Node,
   checker: ts.TypeChecker
 ): VueFileInfo {
-  const defaultExportType = checker.getTypeAtLocation(defaultExport);
+  const defaultExportType = checker.getTypeAtLocation(defaultExportNode);
 
   const props = getProps(tsModule, defaultExportType, checker);
   const data = getData(tsModule, defaultExportType, checker);
@@ -98,6 +98,7 @@ export function getDefaultExportNode(tsModule: T_TypeScript, sourceFile: ts.Sour
 
 function getProps(tsModule: T_TypeScript, defaultExportType: ts.Type, checker: ts.TypeChecker): PropInfo[] | undefined {
   const result: PropInfo[] = getClassAndObjectInfo(tsModule, defaultExportType, checker, getClassProps, getObjectProps);
+  return result.length === 0 ? undefined : result;
 
   function getClassProps(type: ts.Type) {
     const propDecoratorNames = ['Prop', 'Model', 'PropSync'];
@@ -171,8 +172,6 @@ function getProps(tsModule: T_TypeScript, defaultExportType: ts.Type, checker: t
 
     return undefined;
   }
-
-  return result.length === 0 ? undefined : result;
 }
 
 /**
@@ -190,6 +189,7 @@ function getProps(tsModule: T_TypeScript, defaultExportType: ts.Type, checker: t
  */
 function getData(tsModule: T_TypeScript, defaultExportType: ts.Type, checker: ts.TypeChecker): DataInfo[] | undefined {
   const result: DataInfo[] = getClassAndObjectInfo(tsModule, defaultExportType, checker, getClassData, getObjectData);
+  return result.length === 0 ? undefined : result;
 
   function getClassData(type: ts.Type) {
     const noDataDecoratorNames = ['Prop', 'Model', 'Provide', 'ProvideReactive', 'Ref'];
@@ -234,8 +234,6 @@ function getData(tsModule: T_TypeScript, defaultExportType: ts.Type, checker: ts
       };
     });
   }
-
-  return result.length === 0 ? undefined : result;
 }
 
 function getComputed(
@@ -250,6 +248,7 @@ function getComputed(
     getClassComputed,
     getObjectComputed
   );
+  return result.length === 0 ? undefined : result;
 
   function getClassComputed(type: ts.Type) {
     const getAccessorSymbols = type
@@ -295,8 +294,6 @@ function getComputed(
       });
     }
   }
-
-  return result.length === 0 ? undefined : result;
 }
 
 function isInternalHook(methodName: string) {
@@ -331,6 +328,7 @@ function getMethods(
     getClassMethods,
     getObjectMethods
   );
+  return result.length === 0 ? undefined : result;
 
   function getClassMethods(type: ts.Type) {
     const methodSymbols = type
@@ -375,8 +373,6 @@ function getMethods(
       });
     }
   }
-
-  return result.length === 0 ? undefined : result;
 }
 
 function getNodeFromExportNode(tsModule: T_TypeScript, exportExpr: ts.Node): ts.Node | undefined {
@@ -411,8 +407,12 @@ export function isClassType(tsModule: T_TypeScript, type: ts.Type) {
   }
 }
 
-export function getClassDecoratorArgumentType(tsModule: T_TypeScript, type: ts.Type, checker: ts.TypeChecker) {
-  const decorators = type.symbol.declarations[0].decorators;
+export function getClassDecoratorArgumentType(
+  tsModule: T_TypeScript,
+  defaultExportNode: ts.Type,
+  checker: ts.TypeChecker
+) {
+  const decorators = defaultExportNode.symbol.declarations[0].decorators;
   if (!decorators || decorators.length === 0) {
     return undefined;
   }