Add type-checking for assignments

Author: Perryvw

src/config/default-config.ts

@@ -35,6 +35,7 @@ export const DEFAULT_DZNLINT_CONFIG: DefaultDznLintConfig = {
     port_missing_redundant_blocking: false,
     port_parameter_direction: "error",
     trailing_assignments: false,
+    type_check: false,
 };
 
 export const DEFAULT_DZNLINT_FORMAT_CONFIG: DznLintFormatConfiguration = {

src/config/dznlint-configuration.ts

@@ -46,6 +46,7 @@ export interface DznLintConfiguration {
     port_missing_redundant_blocking: ConfigValue;
     port_parameter_direction: ConfigValue;
     trailing_assignments: ConfigValue;
+    type_check: ConfigValue;
 }
 
 export type UserRuleConfig<TRule extends keyof DznLintConfiguration> =

src/linting-rule.ts

@@ -40,6 +40,7 @@ import no_unused_instances from "./rules/no-unused-instances";
 import { port_missing_redundant_blocking } from "./rules/port-missing-redundant-blocking";
 import port_parameter_direction from "./rules/port-parameter-direction";
 import trailing_assignments from "./rules/trailing-assignments";
+import type_check from "./rules/type-check";
 
 export function loadLinters(config: DznLintUserConfiguration) {
     const factories = [
@@ -71,6 +72,7 @@ export function loadLinters(config: DznLintUserConfiguration) {
         port_missing_redundant_blocking,
         port_parameter_direction,
         trailing_assignments,
+        type_check,
     ];
 
     const linters = new Map<ast.SyntaxKind, Linter<ast.AnyAstNode>[]>();

src/rules/type-check.ts

@@ -0,0 +1,118 @@
+// Types assigned to variables and function arguments must match
+
+import * as ast from "../grammar/ast";
+import { getRuleConfig } from "../config/util";
+import { createDiagnosticsFactory } from "../diagnostic";
+import { RuleFactory } from "../linting-rule";
+import { InputSource } from "../semantics/program";
+import { findFirstParent, isDollarsLiteral, isEvent, isFunctionDefinition } from "../util";
+import { Type } from "../semantics";
+
+export const typeMismatch = createDiagnosticsFactory();
+
+export const type_check: RuleFactory = factoryContext => {
+    const config = getRuleConfig("type_check", factoryContext.userConfig);
+
+    if (config.isEnabled) {
+        const createTypeMismatchDiagnostic = (
+            expectedType: Type,
+            actualType: Type,
+            source: InputSource,
+            position: ast.SourceRange
+        ) => {
+            return typeMismatch(
+                config.severity,
+                `Type mismatch: Expected type '${expectedType.name}', but instead got something of type '${actualType.name}'`,
+                source,
+                position
+            );
+        };
+
+        factoryContext.registerRule<ast.VariableDefinition>(ast.SyntaxKind.VariableDefinition, (node, context) => {
+            // initializer type must match lhs type
+            if (node.initializer && !isDollarsLiteral(node.initializer)) {
+                const initializerType = context.typeChecker.typeOfNode(node.initializer);
+                const variableType = context.typeChecker.typeOfNode(node.type);
+
+                if (initializerType !== variableType) {
+                    return [
+                        createTypeMismatchDiagnostic(
+                            variableType,
+                            initializerType,
+                            context.source,
+                            node.initializer.position
+                        ),
+                    ];
+                }
+            }
+
+            return [];
+        });
+
+        factoryContext.registerRule<ast.AssignmentStatement>(ast.SyntaxKind.AssignmentStatement, (node, context) => {
+            // rhs type must match lhs type
+            if (!isDollarsLiteral(node.right)) {
+                const rhsType = context.typeChecker.typeOfNode(node.right);
+                const lhsType = context.typeChecker.typeOfNode(node.left);
+
+                if (rhsType !== lhsType) {
+                    return [createTypeMismatchDiagnostic(lhsType, rhsType, context.source, node.right.position)];
+                }
+            }
+
+            return [];
+        });
+
+        factoryContext.registerRule<ast.CallExpression>(ast.SyntaxKind.CallExpression, (node, context) => {
+            const diagnostics = [];
+
+            const functionSymbol = context.typeChecker.symbolOfNode(node.expression);
+            let parameters: Array<ast.EventParameter | ast.FunctionParameter> = [];
+            if (
+                functionSymbol?.declaration &&
+                (isEvent(functionSymbol.declaration) || isFunctionDefinition(functionSymbol.declaration))
+            ) {
+                parameters = functionSymbol.declaration.parameters;
+            }
+
+            // rhs type must match lhs type
+            let parameterIndex = 0;
+            for (const argument of node.arguments.arguments) {
+                if (!isDollarsLiteral(argument) && parameterIndex < parameters.length) {
+                    const argumentType = context.typeChecker.typeOfNode(argument);
+                    const parameterType = context.typeChecker.typeOfNode(parameters[parameterIndex]);
+
+                    if (argumentType !== parameterType) {
+                        diagnostics.push(
+                            createTypeMismatchDiagnostic(parameterType, argumentType, context.source, argument.position)
+                        );
+                    }
+                }
+                parameterIndex++;
+            }
+
+            return diagnostics;
+        });
+
+        factoryContext.registerRule<ast.ReturnStatement>(ast.SyntaxKind.ReturnStatement, (node, context) => {
+            if (!node.returnValue || isDollarsLiteral(node.returnValue)) return [];
+
+            const parentFunc = findFirstParent(node, isFunctionDefinition);
+
+            if (!parentFunc) return []; // Would be weird to have a return not in a parent
+
+            const returnType = context.typeChecker.typeOfNode(parentFunc.returnType);
+            const returendType = context.typeChecker.typeOfNode(node.returnValue);
+
+            if (returendType != returnType) {
+                return [
+                    createTypeMismatchDiagnostic(returnType, returendType, context.source, node.returnValue.position),
+                ];
+            }
+
+            return [];
+        });
+    }
+};
+
+export default type_check;

src/semantics/type-checker.ts

@@ -216,8 +216,10 @@ export class TypeChecker {
         } else if (
             node.kind === ast.SyntaxKind.Port ||
             node.kind === ast.SyntaxKind.Event ||
+            node.kind === ast.SyntaxKind.EventParameter ||
             node.kind === ast.SyntaxKind.ExternDeclaration ||
             node.kind === ast.SyntaxKind.EnumDefinition ||
+            node.kind === ast.SyntaxKind.FunctionParameter ||
             node.kind === ast.SyntaxKind.Namespace ||
             node.kind === ast.SyntaxKind.Instance ||
             node.kind === ast.SyntaxKind.VariableDefinition ||
@@ -308,6 +310,11 @@ export class TypeChecker {
             const typeSymbol = this.symbolOfNode(definition.type);
             if (!typeSymbol) return ERROR_TYPE;
             return this.typeOfSymbol(typeSymbol);
+        } else if (declaration.kind === ast.SyntaxKind.EventParameter) {
+            const definition = declaration as ast.EventParameter;
+            const typeSymbol = this.symbolOfNode(definition.type);
+            if (!typeSymbol) return ERROR_TYPE;
+            return this.typeOfSymbol(typeSymbol);
         } else if (declaration.kind === ast.SyntaxKind.EnumDefinition) {
             const definition = declaration as ast.EnumDefinition;
             return { kind: TypeKind.Enum, declaration: definition, name: definition.name.text };

src/util.ts

@@ -148,6 +148,10 @@ export function isCompound(node: ast.AnyAstNode): node is ast.Compound {
     return node.kind === ast.SyntaxKind.Compound;
 }
 
+export function isDollarsLiteral(node: ast.AnyAstNode): node is ast.DollarsLiteral {
+    return node.kind === ast.SyntaxKind.DollarLiteral;
+}
+
 export function isEvent(node: ast.AnyAstNode): node is ast.Event {
     return node.kind === ast.SyntaxKind.Event;
 }