feat(idl): add constraints to IDL

Author: dhower-qc

tools/ruby-gems/idlc/lib/idlc.rb

@@ -5,6 +5,7 @@
 # frozen_string_literal: true
 
 require "pathname"
+require "sorbet-runtime"
 require "treetop"
 
 require_relative "idlc/syntax_node"
@@ -44,6 +45,8 @@ class IdlParser < Treetop::Runtime::CompiledParser; end
 module Idl
   # the Idl compiler
   class Compiler
+    extend T::Sig
+
     attr_reader :parser
 
     def initialize
@@ -283,5 +286,42 @@ def compile_expression(expression, symtab, pass_error: false)
 
       ast
     end
+
+    sig { params(body: String, symtab: SymbolTable, pass_error: T::Boolean).returns(ConstraintBodyAst) }
+    def compile_constraint(body, symtab, pass_error: false)
+      m = @parser.parse(body, root: :constraint_body)
+      if m.nil?
+        raise SyntaxError, <<~MSG
+          While parsing #{body}:#{@parser.failure_line}:#{@parser.failure_column}
+
+          #{@parser.failure_reason}
+        MSG
+      end
+
+      # fix up left recursion
+      ast = m.to_ast
+      ast.set_input_file("[CONSTRAINT]", 0)
+      ast.freeze_tree(symtab)
+
+      begin
+        ast.type_check(symtab)
+      rescue AstNode::TypeError => e
+        raise e if pass_error
+
+        warn "Compiling #{body}"
+        warn e.what
+        warn T.must(e.backtrace).to_s
+        exit 1
+      rescue AstNode::InternalError => e
+        raise e if pass_error
+
+        warn "Compiling #{body}"
+        warn e.what
+        warn T.must(e.backtrace).to_s
+        exit 1
+      end
+
+      ast
+    end
   end
 end

tools/ruby-gems/idlc/lib/idlc/ast.rb

@@ -2993,6 +2993,123 @@ def type_check(_symtab)
     end
   end
 
+  class ImplicationExpressionSyntaxNode < SyntaxNode
+    sig { override.returns(ImplicationExpressionAst) }
+    def to_ast
+      ImplicationExpressionAst.new(
+        input, interval,
+        antecedent.to_ast, consequent.to_ast
+      )
+    end
+  end
+
+  class ImplicationExpressionAst < AstNode
+    sig {
+      params(
+        input: String,
+        interval: T::Range[Integer],
+        antecedent: RvalueAst,
+        consequent: RvalueAst
+      ).void
+    }
+    def initialize(input, interval, antecedent, consequent)
+      super(input, interval, [antecedent, consequent])
+    end
+
+    sig { returns(RvalueAst) }
+    def antecedent = @children[0]
+
+    sig { returns(RvalueAst) }
+    def consequent = @children[1]
+
+    sig { override.params(symtab: SymbolTable).void }
+    def type_check(symtab)
+      antecedent.type_error "Antecedent must a boolean" unless antecedent.type(symtab).kind == :boolean
+      consequent.type_error "Consequent must a boolean" unless consequent.type(symtab).kind == :boolean
+    end
+
+    sig { params(symtab: SymbolTable).returns(T::Boolean) }
+    def satisfied?(symtab)
+      return true if antecedent.value(symtab) == false
+      consequent.value(symtab)
+    end
+
+  end
+
+  class ImplicationStatementSyntaxNode < SyntaxNode
+    sig { override.returns(ImplicationStatementAst) }
+    def to_ast
+      ImplicationStatementAst.new(input, interval, implication_expression.to_ast)
+    end
+  end
+
+  class ImplicationStatementAst < AstNode
+    sig {
+      params(
+        input: String,
+        interval: T::Range[Integer],
+        implication_expression: ImplicationExpressionAst
+      ).void
+    }
+    def initialize(input, interval, implication_expression)
+      super(input, interval, [implication_expression])
+    end
+
+    sig { returns(ImplicationExpressionAst) }
+    def expression = @children[0]
+
+    sig { override.params(symtab: SymbolTable).void }
+    def type_check(symtab)
+      expression.type_check(symtab)
+    end
+
+    sig { params(symtab: SymbolTable).returns(T::Boolean) }
+    def satisfied?(symtab)
+      expression.satisfied?(symtab)
+    end
+  end
+
+  class ConstraintBodySyntaxNode < SyntaxNode
+    sig { override.returns(ConstraintBodyAst) }
+    def to_ast
+      stmts = []
+      elements.each do |e|
+        stmts << e.i.to_ast
+      end
+      ConstraintBodyAst.new(input, interval, stmts)
+    end
+  end
+
+  class ConstraintBodyAst < AstNode
+    sig {
+      params(
+        input: String,
+        interval: T::Range[Integer],
+        stmts: T::Array[T.any(ImplicationStatementAst, ForLoopAst)]
+      ).void
+    }
+    def initialize(input, interval, stmts)
+      super(input, interval, stmts)
+    end
+
+    sig { returns(T::Array[T.any(ImplicationStatementAst, ForLoopAst)]) }
+    def stmts = T.cast(@children, T::Array[T.any(ImplicationStatementAst, ForLoopAst)])
+
+    sig { override.params(symtab: SymbolTable).void }
+    def type_check(symtab)
+      stmts.each do |stmt|
+        stmt.type_check(symtab)
+      end
+    end
+
+    sig { params(symtab: SymbolTable).returns(T::Boolean) }
+    def satisfied?(symtab)
+      stmts.all? do |stmt|
+        stmt.satisfied?(symtab)
+      end
+    end
+  end
+
   class WidthRevealSyntaxNode < SyntaxNode
     def to_ast
       WidthRevealAst.new(input, interval, send(:expression).to_ast)
@@ -6429,6 +6546,23 @@ def type_check(symtab)
       symtab.pop
     end
 
+    sig { params(symtab: SymbolTable).returns(T::Boolean) }
+    def satisfied?(symtab)
+      symtab.push(self)
+      begin
+        init.execute(symtab)
+        while condition.value(symtab)
+          stmts.each do |s|
+            return false unless s.satisfied?(symtab)
+          end
+          update.execute(symtab)
+        end
+        return true
+      ensure
+        symtab.pop
+      end
+    end
+
     # @!macro return_value
     def return_value(symtab)
       symtab.push(self)

tools/ruby-gems/idlc/lib/idlc/idl.treetop

@@ -393,6 +393,24 @@ grammar Idl
     e:template_safe_p9_binary_expression space* '?' space* t:expression space* ':' space* f:expression <Idl::TernaryOperatorExpressionSyntaxNode>
   end
 
+  rule implication_expression
+    antecedent:p9_binary_expression space* '->' space* consequent:p9_binary_expression <Idl::ImplicationExpressionSyntaxNode>
+  end
+
+  rule implication_for_loop
+    'for' space* '(' space* single_declaration_with_initialization space* ';' space* condition:expression space* ';' space* action:(assignment / post_inc / post_dec) space*  ')' space* '{' space*
+      stmts:(s:(implication_statement / implication_for_loop) space*)+
+    '}' <Idl::ForLoopSyntaxNode>
+  end
+
+  rule implication_statement
+    implication_expression space* ';' <Idl::ImplicationStatementSyntaxNode>
+  end
+
+  rule constraint_body
+    (i:(implication_statement / implication_for_loop) space*)+ <Idl::ConstraintBodySyntaxNode>
+  end
+
   rule expression
     (
      ternary_expression

tools/ruby-gems/idlc/test/idl/constraint_errors.yaml

@@ -0,0 +1,11 @@
+# Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries.
+
+# SPDX-License-Identifier: BSD-3-Clause-Clear
+
+# c: constraint body, which should cause a type error
+
+tests:
+  - c: |
+      true -> 1;
+  - c: |
+      1 -> false;

tools/ruby-gems/idlc/test/idl/constraints.yaml

@@ -0,0 +1,44 @@
+# Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries.
+
+# SPDX-License-Identifier: BSD-3-Clause-Clear
+
+# c: constraint body
+# r: result -- true if pass, false if not
+
+tests:
+  - c: |
+      true -> true;
+    r: true
+  - c: |
+      true -> false;
+    r: false
+  - c: |
+      false -> true;
+    r: true
+  - c: |
+      false -> false;
+    r: true
+  - c: |
+      (false && true) -> false;
+    r: true
+  - c: |
+      (false || true) -> false;
+    r: false
+  - c: |
+      true -> (false && true);
+    r: false
+  - c: |
+      true -> (false || true);
+    r: true
+  - c: |
+      TRUE_PARAM -> TRUE_PARAM;
+    p:
+      TRUE_PARAM: true
+    r: true
+  - c: |
+      for (U32 i = 0; i < 8; i++) {
+        TRUE_ARRAY[i] -> TRUE_ARRAY[i];
+      }
+    p:
+      TRUE_ARRAY: [true, true, true, true, true, true, true, true]
+    r: true

tools/ruby-gems/idlc/test/run.rb

@@ -1,6 +1,7 @@
 # Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries.
 # SPDX-License-Identifier: BSD-3-Clause-Clear
 
+# typed: false
 # frozen_string_literal: true
 
 require "simplecov"
@@ -14,4 +15,5 @@
 require "minitest/autorun"
 
 require_relative "test_expressions"
+require_relative "test_constraints"
 require_relative "test_cli"

tools/ruby-gems/idlc/test/test_constraints.rb

@@ -0,0 +1,84 @@
+# Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries.
+# SPDX-License-Identifier: BSD-3-Clause-Clear
+
+# typed: false
+# frozen_string_literal: true
+
+require "minitest/autorun"
+
+require "yaml"
+
+require_relative "helpers"
+require "idlc"
+
+$root ||= (Pathname.new(__FILE__) / ".." / ".." / ".." / "..").realpath
+
+def to_idl_type(value)
+  case value
+  when Integer
+    width = value.zero? ? 1 : value.bit_length
+    Idl::Type.new(:bits, width:)
+  when String
+    Idl::Type.new(:string)
+  when TrueClass, FalseClass
+    Idl::Type.new(:boolean)
+  when Array
+    Idl::Type.new(:array, sub_type: to_idl_type(value[0]))
+  else
+    raise "Unexepected type"
+  end
+end
+
+class ConstraintTestFactory
+  def self.create(klass_name, yaml_path)
+    raise ArgumentError, "klass_name must be a String" unless klass_name.is_a?(String) && klass_name.size > 0
+    raise ArgumentError, "klass_name must be uppercase" unless klass_name[0] == klass_name[0].upcase
+
+    # Test IDL constraints
+    Object.const_set(klass_name,
+      Class.new(Minitest::Test) do
+        include TestMixin
+        make_my_diffs_pretty!
+
+        def setup
+          @symtab = Idl::SymbolTable.new
+          @compiler = Idl::Compiler.new
+        end
+
+        test_yaml = YAML.load(File.read("#{Kernel.__dir__}/#{yaml_path}"))
+        test_yaml["tests"].each_with_index do |test, i|
+          define_method "test_#{i}" do
+            if test.key?("p")
+              @symtab.push(nil)
+              test["p"].each do |name, value|
+                @symtab.add!(name, Idl::Var.new(name, to_idl_type(value), value))
+              end
+            end
+            constraint_ast = nil
+            if test["r"].nil?
+              assert_raises Idl::AstNode::TypeError do
+                @compiler.compile_constraint(test["c"], @symtab, pass_error: true)
+              end
+            else
+              out, err = capture_io do
+                constraint_ast = @compiler.compile_constraint(test["c"], @symtab)
+              end
+
+              if test["r"]
+                assert constraint_ast.satisfied?(@symtab)
+              else
+                refute constraint_ast.satisfied?(@symtab)
+              end
+            end
+
+            @symtab.pop if test.key?("p")
+          end
+        end
+      end
+    )
+  end
+end
+
+# now list all the YAML files that specify constraints to test
+ConstraintTestFactory.create("Constraints", "idl/constraints.yaml")
+ConstraintTestFactory.create("BadConstraints", "idl/constraint_errors.yaml")