Add no_out_params_in_out_events rule (#53)

* Add no_out_params_in_out_events

* also disallow inout

* also mention inout in readme

Author: Perryvw

README.md

@@ -181,6 +181,14 @@ In interface behaviors, events should not mention any parameters, this is invali
 
 ---
 
+## no_out_params_in_out_events
+
+For `out` events, parameters cannot be `out` or `inout`, this will be rejected by Dezyne. Instead, the parameter should be marked `in`.
+
+**Possible values:** "hint" | "warning" | **"error"**
+
+---
+
 ## no_recursive_system
 
 Systems cannot contain instances of themself.

src/config/default-config.ts

@@ -21,6 +21,7 @@ export const DEFAULT_DZNLINT_CONFIG: DefaultDznLintConfig = {
     no_empty_defer_capture: "warning",
     no_interface_event_parameters: "error",
     no_mismatching_binding_types: "error",
+    no_out_params_in_out_events: "error",
     no_recursive_system: "error",
     no_shadowing: "warning",
     no_unconnected_ports: "error",

src/config/dznlint-configuration.ts

@@ -32,6 +32,7 @@ export interface DznLintConfiguration {
     no_empty_defer_capture: ConfigValue;
     no_interface_event_parameters: ConfigValue;
     no_mismatching_binding_types: ConfigValue;
+    no_out_params_in_out_events: ConfigValue;
     no_recursive_system: ConfigValue;
     no_shadowing: ConfigValue;
     no_unconnected_ports: ConfigValue;

src/grammar/ast.ts

@@ -207,7 +207,7 @@ export interface FunctionDefinition extends AstNode<SyntaxKind.FunctionDefinitio
     body: Compound | Expression;
 }
 
-export type ParameterDirection = Keyword<"in"> | Keyword<"out">;
+export type ParameterDirection = Keyword<"in"> | Keyword<"out"> | Keyword<"inout">;
 export interface FunctionParameter extends AstNode<SyntaxKind.FunctionParameter> {
     direction?: ParameterDirection;
     type: TypeReference;

src/linting-rule.ts

@@ -28,6 +28,7 @@ import no_duplicate_port_binding from "./rules/no-duplicate-port-binding";
 import no_empty_defer_capture from "./rules/no-empty-defer-capture";
 import no_interface_event_parameters from "./rules/no-interface-event-parameters";
 import no_mismatching_binding_types from "./rules/no-mismatching-binding-types";
+import no_out_params_in_out_events from "./rules/no-out-params-in-out-events";
 import no_unconnected_ports from "./rules/no-unconnected-ports";
 import no_unknown_imports from "./rules/no-unknown-imports";
 import no_unknown_variables from "./rules/no-unknown-variables";
@@ -58,6 +59,7 @@ export function loadLinters(config: DznLintUserConfiguration) {
         no_empty_defer_capture,
         no_interface_event_parameters,
         no_mismatching_binding_types,
+        no_out_params_in_out_events,
         no_recursive_system,
         no_shadowing,
         no_unconnected_ports,

src/rules/never-fired-event.ts

@@ -4,7 +4,7 @@ import * as ast from "../grammar/ast";
 import { getRuleConfig } from "../config/util";
 import { createDiagnosticsFactory, Diagnostic } from "../diagnostic";
 import { RuleFactory } from "../linting-rule";
-import { isCallExpression, isIdentifier } from "../util";
+import { isCallExpression, isIdentifier, isOutEvent } from "../util";
 
 export const neverFiredEvent = createDiagnosticsFactory();
 
@@ -51,7 +51,3 @@ export const never_fired_event: RuleFactory = factoryContext => {
         });
     }
 };
-
-function isOutEvent(node: ast.Event | ast.TypeDefinition): node is ast.Event {
-    return node.kind === ast.SyntaxKind.Event && node.direction.text === "out";
-}

src/rules/no-out-params-in-out-events.ts

@@ -0,0 +1,49 @@
+// no identifiers used for bindings that are unknown
+
+import * as ast from "../grammar/ast";
+import { Diagnostic } from "..";
+import { getRuleConfig } from "../config/util";
+import { createDiagnosticsFactory } from "../diagnostic";
+import { RuleFactory } from "../linting-rule";
+import { isInOutKeyword, isOutEvent, isOutKeyword } from "../util";
+
+export const outParamInOutEvent = createDiagnosticsFactory();
+
+export const no_out_params_in_out_events: RuleFactory = factoryContext => {
+    const config = getRuleConfig("no_out_params_in_out_events", factoryContext.userConfig);
+
+    if (config.isEnabled) {
+        factoryContext.registerRule<ast.Event>(ast.SyntaxKind.Event, (node, context) => {
+            const diagnostics: Diagnostic[] = [];
+
+            if (isOutEvent(node)) {
+                for (const param of node.parameters) {
+                    if (param.direction && isOutKeyword(param.direction)) {
+                        diagnostics.push(
+                            outParamInOutEvent(
+                                config.severity,
+                                "Not allowed to use 'out' parameters in out events, use 'in' instead",
+                                context.source,
+                                param.direction.position
+                            )
+                        );
+                    }
+                    if (param.direction && isInOutKeyword(param.direction)) {
+                        diagnostics.push(
+                            outParamInOutEvent(
+                                config.severity,
+                                "Not allowed to use 'inout' parameters in out events, use 'in' instead",
+                                context.source,
+                                param.direction.position
+                            )
+                        );
+                    }
+                }
+            }
+
+            return diagnostics;
+        });
+    }
+};
+
+export default no_out_params_in_out_events;

src/util.ts

@@ -211,6 +211,18 @@ export function isReplyKeyword(node: ast.AnyAstNode): node is ast.Keyword<"reply
     return isKeyword(node) && node.text === "reply";
 }
 
+export function isInKeyword(node: ast.AnyAstNode): node is ast.Keyword<"in"> {
+    return isKeyword(node) && node.text === "in";
+}
+
+export function isOutKeyword(node: ast.AnyAstNode): node is ast.Keyword<"out"> {
+    return isKeyword(node) && node.text === "out";
+}
+
+export function isInOutKeyword(node: ast.AnyAstNode): node is ast.Keyword<"inout"> {
+    return isKeyword(node) && node.text === "inout";
+}
+
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function isKeyword(node: ast.AnyAstNode): node is ast.Keyword<any> {
     return node.kind === ast.SyntaxKind.Keyword;
@@ -272,6 +284,10 @@ export function isErrorNode(node: ast.AnyAstNode): node is ast.Error {
     return node.kind === ast.SyntaxKind.ERROR;
 }
 
+export function isOutEvent(node: ast.AnyAstNode): node is ast.Event {
+    return isEvent(node) && isOutKeyword(node.direction);
+}
+
 export type ScopedBlock = ast.AnyAstNode &
     (
         | ast.Behavior

test/no-out-params-in-out-event.spec.ts

@@ -0,0 +1,29 @@
+import { outParamInOutEvent } from "../src/rules/no-out-params-in-out-events";
+import { testdznlint } from "./util";
+
+test("not allowed to have out params in out events", async () => {
+    await testdznlint({
+        diagnostic: outParamInOutEvent.code,
+        pass: `
+            extern MyExternType $$;
+            interface I {
+                out void ev(in MyExternType a);
+            }`,
+        fail: `
+            extern MyExternType $$;
+            interface I {
+                out void ev(out MyExternType a);
+            }`,
+    });
+});
+
+test("not allowed to have inout params in out events", async () => {
+    await testdznlint({
+        diagnostic: outParamInOutEvent.code,
+        fail: `
+            extern MyExternType $$;
+            interface I {
+                out void ev(inout MyExternType a);
+            }`,
+    });
+});