add property config resolution

We will now resolve values of variables among other things passed to
property decorators and returned from property getters.

For example:

```ts
const someVariable = {type: String};

// elsewhere...
@Property(someVariable)
```

Author: 43081j

src/analyze/flavors/lit-element/discover-members.ts

@@ -7,7 +7,7 @@ import { lazy } from "../../util/lazy";
 import { resolveNodeValue } from "../../util/resolve-node-value";
 import { camelToDashCase, isNamePrivate } from "../../util/text-util";
 import { AnalyzerDeclarationVisitContext } from "../analyzer-flavor";
-import { getLitElementPropertyDecoratorConfig, getLitPropertyOptions, parseLitPropertyOption } from "./parse-lit-property-configuration";
+import { getLitElementPropertyDecoratorConfig, getLitPropertyOptions, getLitPropertyType } from "./parse-lit-property-configuration";
 
 /**
  * Parses lit-related declaration members.
@@ -174,20 +174,18 @@ function parseStaticProperties(returnStatement: ReturnStatement, context: Analyz
 
 			// Parse the lit property config for this property
 			// Treat non-object-literal-expressions like the "type" (to support Polymer specific syntax)
-			const litConfig = ts.isPropertyAssignment(propNode)
-				? ts.isObjectLiteralExpression(propNode.initializer)
-					? getLitPropertyOptions(propNode.initializer, context)
-					: inPolymerFlavorContext(context)
-					? parseLitPropertyOption(
-							{
-								kind: "type",
-								initializer: propNode.initializer,
-								config: {}
-							},
-							context
-					  )
-					: {}
-				: {};
+			let litConfig: LitElementPropertyConfig = {};
+			if (ts.isPropertyAssignment(propNode)) {
+				if (inPolymerFlavorContext(context) && !ts.isObjectLiteralExpression(propNode.initializer)) {
+					litConfig = { type: getLitPropertyType(ts, propNode.initializer) };
+				} else {
+					const resolved = resolveNodeValue(propNode.initializer, context);
+
+					if (resolved) {
+						litConfig = getLitPropertyOptions(resolved.node, resolved.value, context, litConfig);
+					}
+				}
+			}
 
 			// Get attrName based on the litConfig
 			const attrName = getLitAttributeName(propName, litConfig, context);

src/analyze/flavors/lit-element/parse-lit-property-configuration.ts

@@ -1,4 +1,6 @@
-import { CallExpression, Expression, Node, ObjectLiteralExpression } from "typescript";
+import { SimpleType } from "ts-simple-type";
+import * as tsModule from "typescript";
+import { CallExpression, Node, PropertyAssignment } from "typescript";
 import { AnalyzerVisitContext } from "../../analyzer-visit-context";
 import { LitElementPropertyConfig } from "../../types/features/lit-element-property-config";
 import { resolveNodeValue } from "../../util/resolve-node-value";
@@ -40,8 +42,6 @@ export function getLitElementPropertyDecorator(
  * @param context
  */
 export function getLitElementPropertyDecoratorConfig(node: Node, context: AnalyzerVisitContext): undefined | LitElementPropertyConfig {
-	const { ts } = context;
-
 	// Get reference to a possible "@property" decorator.
 	const decorator = getLitElementPropertyDecorator(node, context);
 
@@ -61,124 +61,112 @@ export function getLitElementPropertyDecoratorConfig(node: Node, context: Analyz
 				break;
 		}
 
-		// Get lit options from the object literal expression
-		return configNode != null && ts.isObjectLiteralExpression(configNode) ? getLitPropertyOptions(configNode, context, config) : config;
+		if (configNode == null) {
+			return config;
+		}
+
+		const resolved = resolveNodeValue(configNode, context);
+
+		return resolved != null ? getLitPropertyOptions(resolved.node, resolved.value, context, config) : config;
 	}
 
 	return undefined;
 }
 
+function hasProperty<T extends string>(obj: object, key: T): obj is { [K in T]: unknown } {
+	return Object.prototype.hasOwnProperty.call(obj, key);
+}
+
+export function getLitPropertyType(ts: typeof tsModule, node: Node): SimpleType | string {
+	const value = ts.isIdentifier(node) ? node.text : undefined;
+
+	switch (value) {
+		case "String":
+		case "StringConstructor":
+			return { kind: "STRING" };
+		case "Number":
+		case "NumberConstructor":
+			return { kind: "NUMBER" };
+		case "Boolean":
+		case "BooleanConstructor":
+			return { kind: "BOOLEAN" };
+		case "Array":
+		case "ArrayConstructor":
+			return { kind: "ARRAY", type: { kind: "ANY" } };
+		case "Object":
+		case "ObjectConstructor":
+			return { kind: "OBJECT", members: [] };
+		default:
+			// This is an unknown type, so set the name as a string
+			return node.getText();
+	}
+}
+
 /**
  * Parses an object literal expression and returns a lit property configuration.
  * @param node
  * @param existingConfig
  * @param context
  */
 export function getLitPropertyOptions(
-	node: ObjectLiteralExpression,
+	node: Node,
+	object: unknown,
 	context: AnalyzerVisitContext,
 	existingConfig: LitElementPropertyConfig = {}
 ): LitElementPropertyConfig {
 	const { ts } = context;
+	const result: LitElementPropertyConfig = { ...existingConfig };
+	let attributeInitializer: Node | undefined;
+	let typeInitializer: Node | undefined;
 
-	// Build up the property configuration by looking at properties in the object literal expression
-	return node.properties.reduce((config, property) => {
-		if (!ts.isPropertyAssignment(property)) return config;
-
-		const initializer = property.initializer;
-		const kind = ts.isIdentifier(property.name) ? property.name.text : undefined;
-
-		return parseLitPropertyOption({ kind, initializer, config }, context);
-	}, existingConfig);
-}
-
-export function parseLitPropertyOption(
-	{ kind, initializer, config }: { kind: string | undefined; initializer: Expression; config: LitElementPropertyConfig },
-	context: AnalyzerVisitContext
-): LitElementPropertyConfig {
-	const { ts, checker } = context;
-
-	// noinspection DuplicateCaseLabelJS
-	switch (kind) {
-		case "converter": {
-			return { ...config, hasConverter: true };
+	if (typeof object === "object" && object !== null && !Array.isArray(object)) {
+		if (hasProperty(object, "converter") && object.converter !== undefined) {
+			result.hasConverter = true;
 		}
 
-		case "reflect": {
-			return { ...config, reflect: resolveNodeValue(initializer, context)?.value === true };
+		if (hasProperty(object, "reflect") && object.reflect !== undefined) {
+			result.reflect = object.reflect === true;
 		}
 
-		case "state": {
-			return { ...config, state: resolveNodeValue(initializer, context)?.value === true };
+		if (hasProperty(object, "state") && object.state !== undefined) {
+			result.state = object.state === true;
 		}
 
-		case "attribute": {
-			let attribute: LitElementPropertyConfig["attribute"] | undefined;
-
-			if (initializer.kind === ts.SyntaxKind.TrueKeyword) {
-				attribute = true;
-			} else if (initializer.kind === ts.SyntaxKind.FalseKeyword) {
-				attribute = false;
-			} else if (ts.isStringLiteral(initializer)) {
-				attribute = initializer.text;
-			}
-
-			return {
-				...config,
-				attribute,
-				node: {
-					...(config.node || {}),
-					attribute: initializer
-				}
-			};
+		if (hasProperty(object, "value")) {
+			result.default = object.value;
 		}
 
-		case "type": {
-			let type: LitElementPropertyConfig["type"] | undefined;
-			const value = ts.isIdentifier(initializer) ? initializer.text : undefined;
-
-			switch (value) {
-				case "String":
-				case "StringConstructor":
-					type = { kind: "STRING" };
-					break;
-				case "Number":
-				case "NumberConstructor":
-					type = { kind: "NUMBER" };
-					break;
-				case "Boolean":
-				case "BooleanConstructor":
-					type = { kind: "BOOLEAN" };
-					break;
-				case "Array":
-				case "ArrayConstructor":
-					type = { kind: "ARRAY", type: { kind: "ANY" } };
-					break;
-				case "Object":
-				case "ObjectConstructor":
-					type = { kind: "OBJECT", members: [] };
-					break;
-				default:
-					// This is an unknown type, so set the name as a string
-					type = initializer.getText();
-					break;
-			}
+		if (hasProperty(object, "attribute") && (typeof object.attribute === "boolean" || typeof object.attribute === "string")) {
+			result.attribute = object.attribute;
 
-			return {
-				...config,
-				type,
-				node: {
-					...(config.node || {}),
-					type: initializer
+			if (ts.isObjectLiteralExpression(node)) {
+				const prop = node.properties.find(
+					(p): p is PropertyAssignment => ts.isPropertyAssignment(p) && ts.isIdentifier(p.name) && p.name.text === "attribute"
+				);
+				if (prop) {
+					attributeInitializer = prop.initializer;
 				}
-			};
+			}
 		}
+	}
+
+	if (ts.isObjectLiteralExpression(node)) {
+		const typeProp = node.properties.find(
+			(p): p is PropertyAssignment => ts.isPropertyAssignment(p) && ts.isIdentifier(p.name) && p.name.text === "type"
+		);
 
-		// Polymer specific field
-		case "value": {
-			return { ...config, default: resolveNodeValue(initializer, { ts, checker })?.value };
+		if (typeProp) {
+			typeInitializer = typeProp.initializer;
+			result.type = getLitPropertyType(ts, typeProp.initializer);
 		}
 	}
 
-	return config;
+	return {
+		...result,
+		node: {
+			...(result.node || {}),
+			attribute: attributeInitializer,
+			type: typeInitializer
+		}
+	};
 }

test/flavors/lit-element/member-test.ts

@@ -55,6 +55,7 @@ tsTest("LitElement: Discovers properties from '@property'", t => {
 		results: [result],
 		checker
 	} = analyzeTextWithCurrentTsModule(`
+	const configVariable = {type: Number};
 	/**
 	 * @element
 	 */
@@ -67,6 +68,8 @@ tsTest("LitElement: Discovers properties from '@property'", t => {
 	    @property({attribute: false}) protected myProp2!: number;
 	    
 	    @property() myProp3;
+
+			@property(configVariable) myProp4;
 	 }
 	 `);
 
@@ -115,6 +118,19 @@ tsTest("LitElement: Discovers properties from '@property'", t => {
 				deprecated: undefined,
 				required: undefined,
 				meta: {}
+			},
+			{
+				kind: "property",
+				propName: "myProp4",
+				attrName: "myProp4",
+				default: undefined,
+				type: () => ({ kind: "NUMBER" }),
+				visibility: "public",
+				deprecated: undefined,
+				required: undefined,
+				meta: {
+					type: { kind: "NUMBER" }
+				}
 			}
 		],
 		t,