@komaci/static-analyzer 242.1.5 → 242.1.6

package/build/index.d.ts

@@ -4,4 +4,5 @@ export { AnalyzerInput, PrimingDiagnostic, Range, Position } from './types';
 export { isSupportedNamespace, isImageComposition } from './shared';
 export { diagnosticMessages, getPrimingDiagnostic } from './rules';
 export * from './validateGetter';
+export * from './validateRenderFunction';
 //# sourceMappingURL=index.d.ts.map

package/build/index.js

@@ -34,4 +34,5 @@ var rules_1 = require("./rules");
 Object.defineProperty(exports, "diagnosticMessages", { enumerable: true, get: function () { return rules_1.diagnosticMessages; } });
 Object.defineProperty(exports, "getPrimingDiagnostic", { enumerable: true, get: function () { return rules_1.getPrimingDiagnostic; } });
 __exportStar(require("./validateGetter"), exports);
+__exportStar(require("./validateRenderFunction"), exports);
 //# sourceMappingURL=index.js.map

package/build/invariantFunctions/returnStatementInvariantFunctions.d.ts

@@ -1,6 +1,7 @@
 import { NodePath } from '@babel/traverse';
 import * as t from '@babel/types';
 import { PrimingDiagnostic } from '../types';
+import { ModuleMetadata } from '@komaci/common-shared';
 /**
  * Invariant function for checking if an getter defined in an external module has only a
  * statement in it, a return statement.
@@ -9,4 +10,19 @@ import { PrimingDiagnostic } from '../types';
  * @returns PrimingDiagnostic of the BlockStatement if the invariant is detected, or undefined if the invariant wasn't found
  */
 export declare function checkExternalModuleGetterReturnStatement(blockStatement: NodePath<t.BlockStatement>, statements: NodePath<t.Statement>[]): PrimingDiagnostic | undefined;
+/**
+ * Invariant function for checking if an render function defined in an external module has only a
+ * statement in it, a return statement.
+ * @param blockStatement the babel path object for the BlockStatement representing the contents of the render function.
+ * @param statements the babel path object array for all of the Statements in the render function.
+ * @returns PrimingDiagnostic of the BlockStatement if the invariant is detected, or undefined if the invariant wasn't found
+ */
+export declare function checkExternalModuleRenderReturnStatement(blockStatement: NodePath<t.BlockStatement>, statements: NodePath<t.Statement>[]): PrimingDiagnostic | undefined;
+/**
+ * Function to validate the render function, returns a priming diagnost if an invariant is found.
+ * @param returnStmt the return satement node
+ * @param moduleMetadata the module metadata obj
+ * @returns a priming diagnostic or undefined.
+ */
+export declare function checkRenderFunctionReturnValues(returnStmt: t.ReturnStatement, moduleMetadata: ModuleMetadata): PrimingDiagnostic | undefined;
 //# sourceMappingURL=returnStatementInvariantFunctions.d.ts.map

package/build/invariantFunctions/returnStatementInvariantFunctions.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.checkExternalModuleGetterReturnStatement = void 0;
+exports.checkRenderFunctionReturnValues = exports.checkExternalModuleRenderReturnStatement = exports.checkExternalModuleGetterReturnStatement = void 0;
 const shared_1 = require("../shared");
 const rules_1 = require("../rules");
 /**
@@ -20,4 +20,63 @@ function checkExternalModuleGetterReturnStatement(blockStatement, statements) {
     return undefined;
 }
 exports.checkExternalModuleGetterReturnStatement = checkExternalModuleGetterReturnStatement;
+/**
+ * Invariant function for checking if an render function defined in an external module has only a
+ * statement in it, a return statement.
+ * @param blockStatement the babel path object for the BlockStatement representing the contents of the render function.
+ * @param statements the babel path object array for all of the Statements in the render function.
+ * @returns PrimingDiagnostic of the BlockStatement if the invariant is detected, or undefined if the invariant wasn't found
+ */
+function checkExternalModuleRenderReturnStatement(blockStatement, statements) {
+    // the render function doesn't only have a return method as expected. Skip traversal, then return from this method here
+    if (!(statements.length === 1 && statements[0].isReturnStatement())) {
+        if (blockStatement.node.loc) {
+            return (0, rules_1.getPrimingDiagnostic)(rules_1.diagnosticMessages.NO_RENDER_FUNCTION_CONTAINS_MORE_THAN_RETURN_STATEMENT, shared_1.LLSRange.fromBabelSourceLocation(blockStatement.node.loc), []);
+        }
+    }
+    return undefined;
+}
+exports.checkExternalModuleRenderReturnStatement = checkExternalModuleRenderReturnStatement;
+/**
+ * Function to validate the render function, returns a priming diagnost if an invariant is found.
+ * @param returnStmt the return satement node
+ * @param moduleMetadata the module metadata obj
+ * @returns a priming diagnostic or undefined.
+ */
+function checkRenderFunctionReturnValues(returnStmt, moduleMetadata) {
+    //eg. return child1;
+    if (returnStmt.argument && returnStmt.argument.type == 'Identifier') {
+        const identifierName = returnStmt.argument.name;
+        const importedTemplateMetadata = moduleMetadata.importsByName.get(identifierName);
+        //the identifier that is being returned was not found in the imports by name array.
+        if (importedTemplateMetadata) {
+            if (!importedTemplateMetadata.templateKomaciDoc) {
+                if (returnStmt.loc) {
+                    return (0, rules_1.getPrimingDiagnostic)(rules_1.diagnosticMessages.NO_RENDER_FUNCTION_RETURN_STATEMENT_NOT_RETURNING_IMPORTED_TEMPLATE, shared_1.LLSRange.fromBabelSourceLocation(returnStmt.loc), []);
+                }
+            }
+        }
+    }
+    else if (returnStmt.argument &&
+        returnStmt.argument.type == 'ConditionalExpression') {
+        const conditionalExpr = returnStmt.argument;
+        const consequence = conditionalExpr.consequent;
+        const alternate = conditionalExpr.alternate;
+        const consequenceTemplateImport = moduleMetadata.importsByName.get(consequence.name);
+        const alternateTemplateImport = moduleMetadata.importsByName.get(alternate.name);
+        if (!consequenceTemplateImport.templateKomaciDoc &&
+            !alternateTemplateImport.templateKomaciDoc) {
+            if (returnStmt.loc) {
+                return (0, rules_1.getPrimingDiagnostic)(rules_1.diagnosticMessages.NO_RENDER_FUNCTION_RETURN_STATEMENT_NOT_RETURNING_IMPORTED_TEMPLATE, shared_1.LLSRange.fromBabelSourceLocation(returnStmt.loc), []);
+            }
+        }
+    }
+    else {
+        if (returnStmt.loc) {
+            return (0, rules_1.getPrimingDiagnostic)(rules_1.diagnosticMessages.NO_RENDER_FUNCTION_RETURN_STATEMENT_NOT_RETURNING_IMPORTED_TEMPLATE, shared_1.LLSRange.fromBabelSourceLocation(returnStmt.loc), []);
+        }
+    }
+    return undefined;
+}
+exports.checkRenderFunctionReturnValues = checkRenderFunctionReturnValues;
 //# sourceMappingURL=returnStatementInvariantFunctions.js.map

package/build/rules.js

@@ -192,6 +192,24 @@ exports.diagnosticMessages = {
         message: 'Supported getters can only contain a return statement',
         source: SOURCE_PREFIX_OFFLINE_CODE_ANALYZER,
     },
+    NO_RENDER_FUNCTION_CONTAINS_MORE_THAN_RETURN_STATEMENT: {
+        code: `${MESSAGE_CODE_PREFIX}1025`,
+        severity: SEVERITY.ERROR,
+        message: 'Supported render functions in custom components can only contain a return statement',
+        source: SOURCE_PREFIX_OFFLINE_CODE_ANALYZER,
+    },
+    NO_RENDER_FUNCTION_RETURN_STATEMENT: {
+        code: `${MESSAGE_CODE_PREFIX}1025`,
+        severity: SEVERITY.ERROR,
+        message: 'Supported render functions need to contain a return statement',
+        source: SOURCE_PREFIX_OFFLINE_CODE_ANALYZER,
+    },
+    NO_RENDER_FUNCTION_RETURN_STATEMENT_NOT_RETURNING_IMPORTED_TEMPLATE: {
+        code: `${MESSAGE_CODE_PREFIX}1025`,
+        severity: SEVERITY.ERROR,
+        message: 'Supported render functions can only return supported imported templates',
+        source: SOURCE_PREFIX_OFFLINE_CODE_ANALYZER,
+    },
     NO_EXPRESSION_CONTAINS_MODULE_LEVEL_VARIABLE_REF: {
         code: `${MESSAGE_CODE_PREFIX}1026`,
         severity: SEVERITY.ERROR,

package/build/validateGetter.d.ts

@@ -33,6 +33,14 @@ export declare function checkFunctionalPurity(path: NodePath<t.ClassMethod | t.C
  *          least one invariant check failed. If no invariant checks failed, an empty Array<InvariantDetail> is returned.
  */
 export declare function validateGetter(getterMethodPath: NodePath<t.ClassMethod>, adgIndex: number, moduleMetadata: ModuleMetadata, moduleContext: ModuleContext, returnSourceLocation?: boolean): boolean | Array<PrimingDiagnostic>;
+/**
+ * Given a set of results from invariant checks. we want to filter out any no-op values and put meaningful
+ * results into the list of allInvalidLocations
+ * @param allInvalidLocations PrimingDiagnostic[] containing all invariants that occurred so far
+ * @param results the Array<PrimingDiagnostic | undefined> containing what is return by calling invariant checker method.
+ * @returns array of PrimingDiagnostic filtered of no-op values/non-meaningful results.
+ */
+export declare function processLocationInfo(allInvalidLocations: PrimingDiagnostic[], results: Array<PrimingDiagnostic | undefined>): PrimingDiagnostic[];
 /**
  * Validate template strings for purity. Variable declarations are not valid inside of a template expression so we do not have to support that use case here.
  * Template string processing is essentially a subset of what we do for getter functions. The only diff is that we don't have to do the extra "only a return statement"

package/build/validateGetter.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateTemplateString = exports.validateGetter = exports.checkFunctionalPurity = void 0;
+exports.validateTemplateString = exports.processLocationInfo = exports.validateGetter = exports.checkFunctionalPurity = void 0;
 const memberExpressionInvariantFunctions_1 = require("./invariantFunctions/memberExpressionInvariantFunctions");
 const callExpressionInvariantFunctions_1 = require("./invariantFunctions/callExpressionInvariantFunctions");
 const assignmentExpressionInvariantFunctions_1 = require("./invariantFunctions/assignmentExpressionInvariantFunctions");
@@ -104,8 +104,8 @@ exports.checkFunctionalPurity = checkFunctionalPurity;
  *          least one invariant check failed. If no invariant checks failed, an empty Array<InvariantDetail> is returned.
  */
 function validateGetter(getterMethodPath, adgIndex, moduleMetadata, moduleContext, returnSourceLocation = false) {
-    const getterDeclaredVars = (0, common_shared_1.getVariablesDeclaredInGetter)(getterMethodPath);
-    const thisAliases = (0, common_shared_1.getThisAliasDeclaredInGetter)(getterMethodPath);
+    const getterDeclaredVars = (0, common_shared_1.getVariablesDeclaredInFunction)(getterMethodPath);
+    const thisAliases = (0, common_shared_1.getThisAliasDeclaredInFunction)(getterMethodPath);
     let primingDiagnostics = checkFunctionalPurity(getterMethodPath, adgIndex, moduleMetadata, moduleContext, {
         thisAliases,
         declaredVariables: getterDeclaredVars,
@@ -138,6 +138,7 @@ function processLocationInfo(allInvalidLocations, results) {
     // concat method returns a new array from the original array + the arrays to concatenate
     return allInvalidLocations.concat(results.filter((result) => result !== undefined));
 }
+exports.processLocationInfo = processLocationInfo;
 /**
  * Validate template strings for purity. Variable declarations are not valid inside of a template expression so we do not have to support that use case here.
  * Template string processing is essentially a subset of what we do for getter functions. The only diff is that we don't have to do the extra "only a return statement"

package/build/validateRenderFunction.d.ts

@@ -0,0 +1,15 @@
+import * as t from '@babel/types';
+import { NodePath } from '@babel/core';
+import { ModuleContext, ModuleMetadata } from '@komaci/common-shared';
+import { PrimingDiagnostic } from './types';
+/**
+ * Function to validate a components render function.
+ * @param renderFunction the render function to validate
+ * @param adgIndex the adg index
+ * @param moduleMetadata the moduleMeta data object
+ * @param moduleContext the module context
+ * @param returnSourceLocation a bool if we want to return the source location
+ * @returns true or false if the function is valid or a priming diagnostic
+ */
+export declare function validateRenderFunction(renderFunction: NodePath<t.ClassMethod>, adgIndex: number, moduleMetadata: ModuleMetadata, moduleContext: ModuleContext, returnSourceLocation?: boolean): boolean | Array<PrimingDiagnostic>;
+//# sourceMappingURL=validateRenderFunction.d.ts.map

package/build/validateRenderFunction.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateRenderFunction = void 0;
+const common_shared_1 = require("@komaci/common-shared");
+const returnStatementInvariantFunctions_1 = require("./invariantFunctions/returnStatementInvariantFunctions");
+const validateGetter_1 = require("./validateGetter");
+const rules_1 = require("./rules");
+const shared_1 = require("./shared");
+/**
+ * Function to validate a components render function.
+ * @param renderFunction the render function to validate
+ * @param adgIndex the adg index
+ * @param moduleMetadata the moduleMeta data object
+ * @param moduleContext the module context
+ * @param returnSourceLocation a bool if we want to return the source location
+ * @returns true or false if the function is valid or a priming diagnostic
+ */
+function validateRenderFunction(renderFunction, adgIndex, moduleMetadata, moduleContext, returnSourceLocation = false) {
+    let primingDiagnostics = [];
+    const declaredVars = (0, common_shared_1.getVariablesDeclaredInFunction)(renderFunction);
+    const thisAliases = (0, common_shared_1.getThisAliasDeclaredInFunction)(renderFunction);
+    //First Check the functional Purity of the render function
+    primingDiagnostics = (0, validateGetter_1.checkFunctionalPurity)(renderFunction, adgIndex, moduleMetadata, moduleContext, {
+        thisAliases,
+        declaredVariables: declaredVars,
+    });
+    const blockStatement = renderFunction.get('body');
+    const statements = blockStatement.get('body');
+    let hasReturnStatement = false;
+    //Visitor object to look at each return statement in the render function and validate it.
+    const Vistior = {
+        ReturnStatement(path) {
+            //Check the if the return statement is valid.
+            hasReturnStatement = true;
+            primingDiagnostics = (0, validateGetter_1.processLocationInfo)(primingDiagnostics, [
+                (0, returnStatementInvariantFunctions_1.checkRenderFunctionReturnValues)(path.node, moduleMetadata),
+            ]);
+        },
+    };
+    renderFunction.traverse(Vistior);
+    //we don't have a return statement in the render function.
+    if (!hasReturnStatement) {
+        if (renderFunction.node.loc) {
+            primingDiagnostics = (0, validateGetter_1.processLocationInfo)(primingDiagnostics, [
+                (0, rules_1.getPrimingDiagnostic)(rules_1.diagnosticMessages.NO_RENDER_FUNCTION_RETURN_STATEMENT, shared_1.LLSRange.fromBabelSourceLocation(renderFunction.node.loc), []),
+            ]);
+        }
+    }
+    // if render function was defined in an external module
+    if (moduleContext.isExternal) {
+        // the render function doesn't only have a return method as expected. Skip traversal, then return from this method here
+        primingDiagnostics = (0, validateGetter_1.processLocationInfo)(primingDiagnostics, [
+            (0, returnStatementInvariantFunctions_1.checkExternalModuleRenderReturnStatement)(blockStatement, statements),
+        ]);
+        // If checkExternalModuleGetterReturnStatement() fails we should just return. There's no use in
+        // validating a function that is already foundationally invalid
+        if (primingDiagnostics.length > 0) {
+            return returnSourceLocation ? primingDiagnostics : false;
+        }
+    }
+    return returnSourceLocation ? primingDiagnostics : primingDiagnostics.length === 0;
+}
+exports.validateRenderFunction = validateRenderFunction;
+//# sourceMappingURL=validateRenderFunction.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@komaci/static-analyzer",
-    "version": "242.1.5",
+    "version": "242.1.6",
     "description": "Komaci Diagnostics API",
     "homepage": "https://komaci.dev/",
     "repository": {
@@ -28,12 +28,12 @@
         "!**/RULES.todo.md"
     ],
     "dependencies": {
-        "@komaci/common-shared": "242.1.5",
+        "@komaci/common-shared": "242.1.6",
         "@lwc/metadata": "2.22.0-0",
         "@lwc/sfdc-compiler-utils": "2.22.0-0"
     },
     "devDependencies": {
         "@babel/types": "^7.9.0",
-        "@komaci/types": "242.1.5"
+        "@komaci/types": "242.1.6"
     }
 }