Merge branch 'chipsalliance:master' into fix/2352
diff --git a/.github/bin/run-format.sh b/.github/bin/run-format.sh index 3c1c724..d5ccfa1 100755 --- a/.github/bin/run-format.sh +++ b/.github/bin/run-format.sh
@@ -31,10 +31,16 @@ FORMAT_OUT=${TMPDIR:-/tmp}/clang-format-diff.out -# Use the provided Clang format binary, or try to fallback to clang-format-17 -# or clang-format. +# Use the provided Clang format binary, or try clang-format-19 (CI version), +# then older numbered versions, then unversioned clang-format. if [[ ! -v CLANG_FORMAT ]]; then - if command -v "clang-format-17" 2>&1 >/dev/null + if command -v "clang-format-19" 2>&1 >/dev/null + then + CLANG_FORMAT="clang-format-19" + elif command -v "clang-format-18" 2>&1 >/dev/null + then + CLANG_FORMAT="clang-format-18" + elif command -v "clang-format-17" 2>&1 >/dev/null then CLANG_FORMAT="clang-format-17" elif command -v "clang-format" 2>&1 >/dev/null @@ -44,6 +50,7 @@ (echo "-- Missing the clang-format binary! --"; exit 1) fi fi +echo "Using ${CLANG_FORMAT} ($("${CLANG_FORMAT}" --version))" BUILDIFIER=${BUILDIFIER:-buildifier}
diff --git a/.github/bin/smoke-projects.hashes b/.github/bin/smoke-projects.hashes new file mode 100644 index 0000000..5298441 --- /dev/null +++ b/.github/bin/smoke-projects.hashes
@@ -0,0 +1,20 @@ +a12778b40ae905f82eb2c23ea4ac037f98099fae https://github.com/jamieiles/80x86 +4da15979747f326bde2f9869c64e587ce599772c https://github.com/pulp-platform/axi +b48037e28544425839dbd617d45b1a82631bc1a9 https://github.com/bespoke-silicon-group/basejump_stl +f91010f654a5dfd00f83dbe25dbda482218d540b https://github.com/black-parrot/black-parrot +86d09682492176a1f8fd1732e469bc2d309453a3 https://github.com/chipsalliance/caliptra-rtl +f9fbd09655ec6ee457438140c13a168390ebd043 https://github.com/chipsalliance/Cores-VeeR-EH2 +3ac6208ed0210ff66a557dd7dc4e79e34f1f2f4a https://github.com/openhwgroup/cva6 +0602ee4627b10f301298f2673d826cdd6baa9327 https://github.com/ijor/fx68k +8b8ee086aef72e0833b7f0493d9d33f1e4d3c8e2 https://github.com/lowRISC/ibex +a19e629a1879801ffcc6f2e6256ca435c20570f3 https://github.com/steveicarus/ivtest +8e83643c22a3ba7612a9bb9cec93292dad618ab5 https://github.com/trivialmips/nontrivial-mips +00981352642fb65ef2b6c47143a0f6bb31fd4a97 https://github.com/lowRISC/opentitan +491a4dc9bb25c33e0183caaf683102b9ce273bc1 https://github.com/gtaylormb/opl3_fpga +7b65f6ba0bce58d4d859082660123b7100aae975 https://github.com/rsd-devel/rsd +ebb5e3551a9d93c0ee95f0b767dd878b8927e702 https://github.com/syntacore/scr1 +f200eb2ed7b69ac1c6b8eddd47654522aeee5ce8 https://github.com/olofk/serv +c4229f3bd5220e6d3ba8f390e5d09c87e462e9c7 https://github.com/chipsalliance/sv-tests +7e9841ff775ea22fba3f222f7bdfe35668345e00 https://github.com/taichi-ishitani/tnoc +5d72b6618acfddece7f09382a032ccbc05862fdc https://github.com/SymbiFlow/uvm +1c8e05fd1e9a79ceb8b996a0996674122eed086f https://github.com/SymbiFlow/XilinxUnisimLibrary
diff --git a/.github/bin/smoke-test.sh b/.github/bin/smoke-test.sh index ba3ff96..5532187 100755 --- a/.github/bin/smoke-test.sh +++ b/.github/bin/smoke-test.sh
@@ -29,16 +29,13 @@ # crash Verible, we're good. ### -# Suppress '... aborted' messages bash would print when a tool crashes. -# Comment out to see syntax errors in bash while working on script. -exec 2>/dev/null - set -u # Be strict: only allow using a variable after it is assigned BAZEL_BUILD_OPTIONS="-c opt" TMPDIR="${TMPDIR:-/tmp}" readonly BASE_TEST_DIR="${TMPDIR}/test/verible-smoke-test" +readonly PROJECT_HASHES_FILE="$(dirname $0)/smoke-projects.hashes" # Write log files to this directory readonly SMOKE_LOGGING_DIR="${SMOKE_LOGGING_DIR:-$BASE_TEST_DIR/error-logs}" @@ -81,29 +78,11 @@ # # There are some known issues which are all recorded in the associative # array below, mapping them to Verible issue tracker numbers. -# TODO(hzeller): there should be a configuration file that contains two -# columns: URL + hash, so that we can fetch a particular known version not -# a moving target. -readonly TEST_GIT_PROJECTS="https://github.com/lowRISC/ibex \ - https://github.com/lowRISC/opentitan \ - https://github.com/chipsalliance/sv-tests \ - https://github.com/chipsalliance/Cores-VeeR-EH2 \ - https://github.com/chipsalliance/caliptra-rtl \ - https://github.com/openhwgroup/cva6 \ - https://github.com/SymbiFlow/uvm \ - https://github.com/taichi-ishitani/tnoc \ - https://github.com/ijor/fx68k \ - https://github.com/jamieiles/80x86 \ - https://github.com/SymbiFlow/XilinxUnisimLibrary \ - https://github.com/black-parrot/black-parrot - https://github.com/steveicarus/ivtest \ - https://github.com/trivialmips/nontrivial-mips \ - https://github.com/pulp-platform/axi \ - https://github.com/rsd-devel/rsd \ - https://github.com/syntacore/scr1 \ - https://github.com/olofk/serv \ - https://github.com/bespoke-silicon-group/basejump_stl \ - https://github.com/gtaylormb/opl3_fpga" + +if [ ! -f "${PROJECT_HASHES_FILE}" ]; then + echo "Project hashes file not found: ${PROJECT_HASHES_FILE}" + exit 1 +fi ## # Some of the files in the projects will have issues. @@ -135,24 +114,24 @@ ExpectedFailCount[syntax:ibex]=13 ExpectedFailCount[lint:ibex]=13 -ExpectedFailCount[project:ibex]=218 -ExpectedFailCount[preprocessor:ibex]=397 +ExpectedFailCount[project:ibex]=224 +ExpectedFailCount[preprocessor:ibex]=403 ExpectedFailCount[syntax:opentitan]=88 ExpectedFailCount[lint:opentitan]=88 -ExpectedFailCount[project:opentitan]=1068 +ExpectedFailCount[project:opentitan]=1077 ExpectedFailCount[formatter:opentitan]=0 -ExpectedFailCount[preprocessor:opentitan]=3074 +ExpectedFailCount[preprocessor:opentitan]=3017 ExpectedFailCount[syntax:sv-tests]=74 ExpectedFailCount[lint:sv-tests]=73 ExpectedFailCount[project:sv-tests]=176 -ExpectedFailCount[preprocessor:sv-tests]=128 +ExpectedFailCount[preprocessor:sv-tests]=129 -ExpectedFailCount[syntax:caliptra-rtl]=39 -ExpectedFailCount[lint:caliptra-rtl]=38 -ExpectedFailCount[project:caliptra-rtl]=453 -ExpectedFailCount[preprocessor:caliptra-rtl]=911 +ExpectedFailCount[syntax:caliptra-rtl]=41 +ExpectedFailCount[lint:caliptra-rtl]=40 +ExpectedFailCount[project:caliptra-rtl]=474 +ExpectedFailCount[preprocessor:caliptra-rtl]=993 ExpectedFailCount[syntax:Cores-VeeR-EH2]=2 ExpectedFailCount[lint:Cores-VeeR-EH2]=2 @@ -164,10 +143,10 @@ ExpectedFailCount[project:cva6]=84 ExpectedFailCount[preprocessor:cva6]=140 -ExpectedFailCount[syntax:uvm]=0 -ExpectedFailCount[lint:uvm]=0 -ExpectedFailCount[project:uvm]=40 -ExpectedFailCount[preprocessor:uvm]=126 +ExpectedFailCount[syntax:uvm]=1 +ExpectedFailCount[lint:uvm]=1 +ExpectedFailCount[project:uvm]=41 +ExpectedFailCount[preprocessor:uvm]=128 ExpectedFailCount[syntax:tnoc]=3 ExpectedFailCount[lint:tnoc]=3 @@ -187,9 +166,9 @@ ExpectedFailCount[project:black-parrot]=172 ExpectedFailCount[preprocessor:black-parrot]=173 -ExpectedFailCount[syntax:ivtest]=117 -ExpectedFailCount[lint:ivtest]=117 -ExpectedFailCount[project:ivtest]=146 +ExpectedFailCount[syntax:ivtest]=116 +ExpectedFailCount[lint:ivtest]=116 +ExpectedFailCount[project:ivtest]=145 ExpectedFailCount[preprocessor:ivtest]=26 ExpectedFailCount[syntax:nontrivial-mips]=2 @@ -237,11 +216,10 @@ expected_count_key="${TOOL_SHORT_NAME}:${PROJECT_NAME}" if [[ -v ExpectedFailCount[${expected_count_key}] ]]; then expected_count=${ExpectedFailCount[${expected_count_key}]} - # We allow some 5% deviation from expected values before we complain loudly - local GRACE_VALUE=$(( ${expected_count} / 20 )) - if [ ${GRACE_VALUE} -lt 2 ]; then - GRACE_VALUE=2 - fi + + # Since we have a fixed set of projects and hashes, we don't allow any + # derivation from the expected value (used to be 5%) + local GRACE_VALUE=0 if [ ${OBSERVED_NONZERO_COUNT} -gt ${expected_count} ] ; then local ALLOWED_UP_TO=$((${expected_count} + ${GRACE_VALUE})) if [ ${OBSERVED_NONZERO_COUNT} -gt ${ALLOWED_UP_TO} ]; then @@ -254,6 +232,7 @@ elif [ ${OBSERVED_NONZERO_COUNT} -lt ${expected_count} ] ; then echo "::notice:: 🎉 Yay, reduced non-zero exit count ${expected_count} -> ${OBSERVED_NONZERO_COUNT}" echo "Set ExpectedFailCount[${TOOL_SHORT_NAME}:${PROJECT_NAME}]=${OBSERVED_NONZERO_COUNT}" + return 1 # we still want the exact value to be recorded so actively fail fi else if [ ${OBSERVED_NONZERO_COUNT} -gt 0 ] ; then @@ -270,11 +249,14 @@ # # First parameter : project name # Second parameter: name of file containing a list of {System}Verilog files +# Third parameter : git URL +# Fourth parameter: git hash (optional, defaults to master) function run_smoke_test() { local PROJECT_FILE_LIST=${TMPDIR}/filelist.$$.list local PROJECT_NAME=$1 local FILELIST=$2 local GIT_URL=$3 + local GIT_HASH=${4:-master} local NUM_FILES=$(wc -l < ${FILELIST}) local result=0 @@ -355,7 +337,7 @@ else # This is an so far unknown issue echo "::error:: 😱 ${single_file}: crash exit code $EXIT_CODE for $tool" - echo "Input File URL: ${GIT_URL}/blob/master/$(echo $single_file | cut -d/ -f6-)" + echo "Input File URL: ${GIT_URL}/blob/${GIT_HASH}/$(echo $single_file | cut -d/ -f6-)" head -15 ${PROJECT_FILE_TOOL_OUT} # Might be useful in this case result=$((${result} + 1)) fi @@ -372,8 +354,55 @@ return ${result} } +# --- main + +KEEP_LOGS=0 +VERBOSE=0 +PROJECT_FILTER="" + +while [[ $# -gt 0 ]]; do + case "$1" in + --keep-logs) + KEEP_LOGS=1 + shift + ;; + --verbose|-v) + VERBOSE=1 + shift + ;; + --filter=*) + PROJECT_FILTER="${1#*=}" + shift + ;; + --filter|-f) + if [[ $# -lt 2 ]]; then + echo "Error: $1 requires an argument." >&2 + exit 1 + fi + PROJECT_FILTER="$2" + shift 2 + ;; + -h|--help) + echo "Usage: $0 [--keep-logs] [--verbose] [--filter=<name>]" + exit 0 + ;; + *) + echo "Unknown option: $1" >&2 + echo "Usage: $0 [--keep-logs] [--verbose] [--filter=<name>]" >&2 + exit 1 + ;; + esac +done + +if [ ${VERBOSE} -eq 0 ]; then + # Suppress '... aborted' messages bash would print when a tool crashes. + exec 2>/dev/null +fi + mkdir -p "${BASE_TEST_DIR}" -trap 'rm -rf -- "${BASE_TEST_DIR}"' EXIT +if [ ${KEEP_LOGS} -eq 0 ]; then + trap 'rm -rf -- "${BASE_TEST_DIR}"' EXIT +fi status_sum=0 @@ -388,18 +417,26 @@ bazel build ${BAZEL_BUILD_OPTIONS} :install-binaries & # While compiling, run potentially slow network ops -for git_project in ${TEST_GIT_PROJECTS} ; do - PROJECT_NAME="$(basename $git_project)" +while read -r git_hash git_project _; do + [[ -z "${git_hash}" || "${git_hash}" =~ ^# ]] && continue + PROJECT_NAME="$(basename "${git_project}")" + if [[ -n "${PROJECT_FILTER}" && "${PROJECT_NAME}" != *"${PROJECT_FILTER}"* ]]; then + continue + fi PROJECT_DIR="${BASE_TEST_DIR}/${PROJECT_NAME}" - git clone ${git_project} ${PROJECT_DIR} 2>/dev/null & -done + ( git clone "${git_project}" "${PROJECT_DIR}" && git -C "${PROJECT_DIR}" checkout -q "${git_hash}" ) 2>/dev/null & +done < "${PROJECT_HASHES_FILE}" echo "base test dir ${BASE_TEST_DIR}; writing logs to ${SMOKE_LOGGING_DIR}" echo "Waiting... for compilation and project download finished" wait -for git_project in ${TEST_GIT_PROJECTS} ; do - PROJECT_NAME="$(basename $git_project)" +while read -r git_hash git_project _; do + [[ -z "${git_hash}" || "${git_hash}" =~ ^# ]] && continue + PROJECT_NAME="$(basename "${git_project}")" + if [[ -n "${PROJECT_FILTER}" && "${PROJECT_NAME}" != *"${PROJECT_FILTER}"* ]]; then + continue + fi PROJECT_DIR="${BASE_TEST_DIR}/${PROJECT_NAME}" # Already cloned above @@ -412,17 +449,17 @@ FILELIST="${PROJECT_DIR}/verible.filelist" find "${PROJECT_DIR}" -name "*.sv" -o -name "*.svh" -o -name "*.v" | sort > ${FILELIST} - run_smoke_test "${PROJECT_NAME}" "${FILELIST}" "${git_project}" + run_smoke_test "${PROJECT_NAME}" "${FILELIST}" "${git_project}" "${git_hash}" status_sum=$((${status_sum} + $?)) echo -done +done < "${PROJECT_HASHES_FILE}" echo "::endgroup::" -echo "There were a total of ${status_sum} new, undocumented issues." +echo "There were a total of ${status_sum} mismatches" # Let's see if there are any issues that are fixed in the meantime. -if [ "${#KnownIssue[@]}" -ne 0 ]; then +if [ -z "${PROJECT_FILTER}" ] && [ "${#KnownIssue[@]}" -ne 0 ]; then echo "::warning ::There are ${#KnownIssue[@]} tool/file combinations, that no longer fail" declare -A DistinctIssues for key in "${!KnownIssue[@]}"; do @@ -434,7 +471,10 @@ for issue_id in "${!DistinctIssues[@]}"; do echo " 🐞 ${ISSUE_PREFIX}/${issue_id}" done - echo +fi + +if [ ${KEEP_LOGS} -ne 0 ]; then + echo "Logs and project files kept in ${BASE_TEST_DIR} (error logs: ${SMOKE_LOGGING_DIR})" fi exit ${status_sum}
diff --git a/.github/workflows/verible-ci.yml b/.github/workflows/verible-ci.yml index 5f03f2f..802a7a3 100644 --- a/.github/workflows/verible-ci.yml +++ b/.github/workflows/verible-ci.yml
@@ -34,6 +34,11 @@ with: fetch-depth: 0 + - name: Set up Go + uses: actions/setup-go@v5 + with: + go-version: 'stable' + - name: Install Dependencies run: | sudo apt-get install clang-format-19
diff --git a/README.md b/README.md index b813b76..047fb20 100644 --- a/README.md +++ b/README.md
@@ -172,8 +172,9 @@ Verible's code base is written in C++. -To build, you need the [bazel] build system (Min version 7) and a C++20 -compatible compiler. +To build, you need the [bazel] build system (get it from +[bazel install][bazel-install] if not already on your system) and a +C++20 compatible compiler. Use your package manager to install the dependencies; on a system with the nix package manager simply run `nix-shell` to get a build environment. @@ -199,6 +200,8 @@ bazel build -c opt --config=create_static_linked_executables //... ``` +See [Installation](#installation-1) for install. + ### Optionally using local flex/bison for build Flex and Bison, that are needed for the parser generation, are compiled as part @@ -283,6 +286,7 @@ [UHDM] format. If you are interested in collaborating, contact us. [bazel]: https://bazel.build/ +[bazel-install]: https://bazel.build/install [SV-LRM]: https://ieeexplore.ieee.org/document/8299595 [lint-rule-list]: https://chipsalliance.github.io/verible/lint.html [github-lint-action]: https://github.com/chipsalliance/verible-linter-action
diff --git a/shell.nix b/shell.nix index 85163eb..408340b 100644 --- a/shell.nix +++ b/shell.nix
@@ -8,6 +8,17 @@ #verible_used_stdenv = pkgs.gcc15Stdenv; #verible_used_stdenv = pkgs.clang19Stdenv; bazel = pkgs.bazel_8; + + + userNixPath = ./user.nix; # optional user config + userPackages = + if builtins.pathExists userNixPath + then + let loaded = import userNixPath; + in if builtins.isFunction loaded + then loaded { inherit pkgs; } + else loaded + else []; in verible_used_stdenv.mkDerivation { name = "verible-build-environment"; @@ -40,7 +51,7 @@ llvmPackages_22.clang-tools # for clang-tidy llvmPackages_19.clang-tools # for clang-format - ]; + ] ++ userPackages; shellHook = '' # clang tidy: use latest. export CLANG_TIDY=${pkgs.llvmPackages_22.clang-tools}/bin/clang-tidy
diff --git a/verible/common/util/BUILD b/verible/common/util/BUILD index 48a2105..db499b4 100644 --- a/verible/common/util/BUILD +++ b/verible/common/util/BUILD
@@ -22,7 +22,6 @@ hdrs = ["auto-pop-stack.h"], deps = [ ":logging", - "@abseil-cpp//absl/base:core_headers", ], )
diff --git a/verible/common/util/auto-pop-stack.h b/verible/common/util/auto-pop-stack.h index 024ef05..58628eb 100644 --- a/verible/common/util/auto-pop-stack.h +++ b/verible/common/util/auto-pop-stack.h
@@ -18,7 +18,6 @@ #include <cstddef> #include <vector> -#include "absl/base/attributes.h" #include "verible/common/util/logging.h" namespace verible { @@ -29,7 +28,7 @@ // implementing algorithms based on stack data structures like building // inheritance stack of traversed tree. template <typename T> -class AutoPopStack { +class [[maybe_unused]] AutoPopStack { public: using value_type = T; using this_type = AutoPopStack<value_type>; @@ -105,7 +104,7 @@ private: stack_type stack_; -} ABSL_ATTRIBUTE_UNUSED; +}; } // namespace verible
diff --git a/verible/common/util/container-proxy_test.cc b/verible/common/util/container-proxy_test.cc index 5e8220f..4e4cd75 100644 --- a/verible/common/util/container-proxy_test.cc +++ b/verible/common/util/container-proxy_test.cc
@@ -874,13 +874,14 @@ const int new_capacity = initial_capacity + 42; this->proxy.reserve(new_capacity); - EXPECT_EQ(this->proxy.capacity(), new_capacity); - EXPECT_EQ(this->container.capacity(), new_capacity); + EXPECT_GE(this->proxy.capacity(), new_capacity); + EXPECT_EQ(this->proxy.capacity(), this->container.capacity()); + const int capacity_after_first_reserve = this->proxy.capacity(); const int lower_capacity = 1; this->proxy.reserve(lower_capacity); - EXPECT_EQ(this->proxy.capacity(), new_capacity); - EXPECT_EQ(this->container.capacity(), new_capacity); + EXPECT_EQ(this->proxy.capacity(), capacity_after_first_reserve); + EXPECT_EQ(this->container.capacity(), capacity_after_first_reserve); } } // namespace
diff --git a/verible/verilog/analysis/checkers/BUILD b/verible/verilog/analysis/checkers/BUILD index bd3a98b..4681607 100644 --- a/verible/verilog/analysis/checkers/BUILD +++ b/verible/verilog/analysis/checkers/BUILD
@@ -817,6 +817,7 @@ "//verible/common/analysis:syntax-tree-lint-rule", "//verible/common/analysis/matcher", "//verible/common/analysis/matcher:bound-symbol-manager", + "//verible/common/text:config-utils", "//verible/common/text:symbol", "//verible/common/text:syntax-tree-context", "//verible/common/text:token-info", @@ -826,7 +827,9 @@ "//verible/verilog/CST:verilog-nonterminals", "//verible/verilog/analysis:descriptions", "//verible/verilog/analysis:lint-rule-registry", + "@abseil-cpp//absl/status", "@abseil-cpp//absl/strings", + "@re2", ], alwayslink = 1, ) @@ -1821,6 +1824,7 @@ "//verible/common/text:symbol", "//verible/common/text:syntax-tree-context", "//verible/common/text:token-info", + "//verible/common/util:container-util", "//verible/verilog/CST:port", "//verible/verilog/CST:verilog-matchers", "//verible/verilog/analysis:descriptions",
diff --git a/verible/verilog/analysis/checkers/generate-label-prefix-rule.cc b/verible/verilog/analysis/checkers/generate-label-prefix-rule.cc index c8822ce..e678ad5 100644 --- a/verible/verilog/analysis/checkers/generate-label-prefix-rule.cc +++ b/verible/verilog/analysis/checkers/generate-label-prefix-rule.cc
@@ -14,12 +14,17 @@ #include "verible/verilog/analysis/checkers/generate-label-prefix-rule.h" +#include <memory> +#include <string> #include <string_view> -#include "absl/strings/match.h" +#include "absl/status/status.h" +#include "absl/strings/str_cat.h" +#include "re2/re2.h" #include "verible/common/analysis/lint-rule-status.h" #include "verible/common/analysis/matcher/bound-symbol-manager.h" #include "verible/common/analysis/matcher/matcher.h" +#include "verible/common/text/config-utils.h" #include "verible/common/text/symbol.h" #include "verible/common/text/syntax-tree-context.h" #include "verible/common/text/token-info.h" @@ -38,22 +43,36 @@ // Register the lint rule VERILOG_REGISTER_LINT_RULE(GenerateLabelPrefixRule); -static constexpr std::string_view kMessage = - "All generate block labels must start with g_ or gen_"; +static constexpr std::string_view kDefaultStyleRegex = "(g_|gen_).*"; -// TODO(fangism): and be lower_snake_case? -// TODO(fangism): generalize to a configurable pattern and -// rename this class/rule to GenerateLabelNamingStyle? +GenerateLabelPrefixRule::GenerateLabelPrefixRule() + : style_regex_( + std::make_unique<re2::RE2>(kDefaultStyleRegex, re2::RE2::Quiet)) {} const LintRuleDescriptor &GenerateLabelPrefixRule::GetDescriptor() { static const LintRuleDescriptor d{ .name = "generate-label-prefix", .topic = "generate-constructs", - .desc = "Checks that every generate block label starts with g_ or gen_.", + .desc = + "Checks that every generate block label matches the regex defined by " + "style_regex. The default regex requires labels to start with g_ or " + "gen_. Refer to https://github.com/chipsalliance/verible/tree/master/" + "verilog/tools/lint#readme for more detail on verible regex " + "patterns.", + // NOLINTNEXTLINE(misc-include-cleaner) + .param = {{"style_regex", std::string(kDefaultStyleRegex), + "A regex used to check generate label style."}}, }; return d; } +std::string GenerateLabelPrefixRule::CreateViolationMessage() const { + return absl::StrCat( + "Generate block label does not match the naming convention defined by " + "regex pattern: ", + style_regex_->pattern()); +} + // Matches begin statements static const Matcher &BlockMatcher() { static const Matcher matcher(NodekGenerateBlock()); @@ -84,15 +103,24 @@ } if (label != nullptr) { - if (!(absl::StartsWith(label->text(), "g_") || - absl::StartsWith(label->text(), "gen_"))) { - violations_.insert(verible::LintViolation(*label, kMessage, context)); + if (!RE2::FullMatch(label->text(), *style_regex_)) { + violations_.insert(verible::LintViolation( + *label, CreateViolationMessage(), context)); } } } } } +// NOLINTNEXTLINE(misc-include-cleaner) +absl::Status GenerateLabelPrefixRule::Configure( + std::string_view configuration) { + using verible::config::SetRegex; + absl::Status s = verible::ParseNameValues( + configuration, {{"style_regex", SetRegex(&style_regex_)}}); + return s; +} + verible::LintRuleStatus GenerateLabelPrefixRule::Report() const { return verible::LintRuleStatus(violations_, GetDescriptor()); }
diff --git a/verible/verilog/analysis/checkers/generate-label-prefix-rule.h b/verible/verilog/analysis/checkers/generate-label-prefix-rule.h index 9090cf3..e18df9c 100644 --- a/verible/verilog/analysis/checkers/generate-label-prefix-rule.h +++ b/verible/verilog/analysis/checkers/generate-label-prefix-rule.h
@@ -15,8 +15,13 @@ #ifndef VERIBLE_VERILOG_ANALYSIS_CHECKERS_GENERATE_LABEL_PREFIX_RULE_H_ #define VERIBLE_VERILOG_ANALYSIS_CHECKERS_GENERATE_LABEL_PREFIX_RULE_H_ +#include <memory> #include <set> +#include <string> +#include <string_view> +#include "absl/status/status.h" +#include "re2/re2.h" #include "verible/common/analysis/lint-rule-status.h" #include "verible/common/analysis/syntax-tree-lint-rule.h" #include "verible/common/text/symbol.h" @@ -27,20 +32,28 @@ namespace analysis { // GenerateLabelPrefixRule checks that all generate block labels start -// with g_ or gen_ +// with g_ or gen_ (configurable via style_regex) class GenerateLabelPrefixRule : public verible::SyntaxTreeLintRule { public: using rule_type = verible::SyntaxTreeLintRule; + GenerateLabelPrefixRule(); + static const LintRuleDescriptor &GetDescriptor(); + std::string CreateViolationMessage() const; + void HandleSymbol(const verible::Symbol &symbol, const verible::SyntaxTreeContext &context) final; verible::LintRuleStatus Report() const final; + absl::Status Configure(std::string_view configuration) final; + private: std::set<verible::LintViolation> violations_; + + std::unique_ptr<re2::RE2> style_regex_; }; } // namespace analysis
diff --git a/verible/verilog/analysis/checkers/generate-label-prefix-rule_test.cc b/verible/verilog/analysis/checkers/generate-label-prefix-rule_test.cc index b46bfe4..cb43501 100644 --- a/verible/verilog/analysis/checkers/generate-label-prefix-rule_test.cc +++ b/verible/verilog/analysis/checkers/generate-label-prefix-rule_test.cc
@@ -27,6 +27,7 @@ namespace { using verible::LintTestCase; +using verible::RunConfiguredLintTestCases; using verible::RunLintTestCases; TEST(GenerateLabelPrefixRuleTest, Various) { @@ -229,6 +230,40 @@ RunLintTestCases<VerilogAnalyzer, GenerateLabelPrefixRule>(kTestCases); } +TEST(GenerateLabelPrefixRuleTest, CustomRegex) { + const std::initializer_list<LintTestCase> kTestCases = { + {"module m;\n" + "generate\n" + "if (1) begin : my_custom_label\n" + "end\n" + "endgenerate\nendmodule\n"}, + {"module m;\n" + "generate\n" + "for (genvar i=0; i<5; i++) begin : my_custom_label\n" + "end\n" + "endgenerate\nendmodule\n"}, + }; + RunConfiguredLintTestCases<VerilogAnalyzer, GenerateLabelPrefixRule>( + kTestCases, "style_regex:my_.*"); + + const std::initializer_list<LintTestCase> kFailCases = { + {"module m;\n" + "generate\n" + "if (1) begin : ", + {SymbolIdentifier, "g_label"}, + "\nend\n" + "endgenerate\nendmodule\n"}, + {"module m;\n" + "generate\n" + "if (1) begin : ", + {SymbolIdentifier, "gen_label"}, + "\nend\n" + "endgenerate\nendmodule\n"}, + }; + RunConfiguredLintTestCases<VerilogAnalyzer, GenerateLabelPrefixRule>( + kFailCases, "style_regex:my_.*"); +} + } // namespace } // namespace analysis } // namespace verilog
diff --git a/verible/verilog/analysis/checkers/port-name-suffix-rule.cc b/verible/verilog/analysis/checkers/port-name-suffix-rule.cc index 85a0db3..ffecef3 100644 --- a/verible/verilog/analysis/checkers/port-name-suffix-rule.cc +++ b/verible/verilog/analysis/checkers/port-name-suffix-rule.cc
@@ -28,6 +28,7 @@ #include "verible/common/text/symbol.h" #include "verible/common/text/syntax-tree-context.h" #include "verible/common/text/token-info.h" +#include "verible/common/util/container-util.h" #include "verible/verilog/CST/port.h" #include "verible/verilog/CST/verilog-matchers.h" #include "verible/verilog/analysis/descriptions.h" @@ -90,10 +91,16 @@ {"output", {"o", "no", "po"}}, {"inout", {"io", "nio", "pio"}}}; - // At this point it is guaranteed that the direction will be set to - // one of the expected values (used as keys in the map above). - // Therefore checking the suffix like this is safe - return suffixes.at(direction).count(suffix) == 1; + // `direction` is usually one of the map keys, but the grammar also permits a + // `ref` port direction, which has no suffix convention. FindWithDefault looks + // the direction up with an empty-set fallback, so an unknown direction (e.g. + // `ref`) has no required suffixes and is treated as "correct" (no violation), + // consistent with Violation() which also ignores non-input/output/inout + // directions. + static const std::set<std::string_view> kNoConvention; + const std::set<std::string_view> &valid = + verible::container::FindWithDefault(suffixes, direction, kNoConvention); + return valid.empty() || valid.count(suffix) == 1; } void PortNameSuffixRule::HandleSymbol(const Symbol &symbol, @@ -113,8 +120,11 @@ absl::StrSplit(name, '_', absl::SkipEmpty()); if (name_parts.size() < 2) { - // No suffix at all + // No suffix at all. This also covers an all-underscore name (e.g. "_"), + // for which SkipEmpty leaves name_parts empty; return here so the + // name_parts.back() access below is not reached on an empty vector. Violation(direction, token, context); + return; } if (!IsSuffixCorrect(name_parts.back(), direction)) {
diff --git a/verible/verilog/analysis/checkers/port-name-suffix-rule_test.cc b/verible/verilog/analysis/checkers/port-name-suffix-rule_test.cc index 69f18f4..db69d71 100644 --- a/verible/verilog/analysis/checkers/port-name-suffix-rule_test.cc +++ b/verible/verilog/analysis/checkers/port-name-suffix-rule_test.cc
@@ -57,6 +57,9 @@ {"module t (input bit name_i); endmodule;"}, {"module t (output bit abc_o); endmodule;"}, {"module t (inout bit xyz_io); endmodule;"}, + // A `ref` port has no suffix convention and must not be flagged (and must + // not crash the rule via std::map::at). + {"module t (ref logic data_x); endmodule;"}, {"module t (input logic name_i,\n" "output logic abc_o,\n" "inout logic xyz_io,\n" @@ -90,6 +93,10 @@ {"module t (output logic ", {kToken, "_o"}, "); endmodule;"}, {"module t (inout logic ", {kToken, "_io"}, "); endmodule;"}, + // An all-underscore name splits (SkipEmpty) to an empty parts list; it + // must report a suffix violation, not dereference an empty vector. + {"module t (input logic ", {kToken, "_"}, "); endmodule;"}, + {"module t (input logic ", {kToken, "namei"}, "); endmodule;"}, {"module t (input logic ", {kToken, "nam_ei"}, "); endmodule;"}, {"module t (input logic ", {kToken, "name_o"}, "); endmodule;"},
diff --git a/verible/verilog/analysis/symbol-table_test.cc b/verible/verilog/analysis/symbol-table_test.cc index e15ec5f..3e6b1a6 100644 --- a/verible/verilog/analysis/symbol-table_test.cc +++ b/verible/verilog/analysis/symbol-table_test.cc
@@ -73,8 +73,7 @@ const auto found_##dest(map.find(key)); /* iterator */ \ ASSERT_NE(found_##dest, map.end()) \ << "No element at \"" << key << "\" in " #map; \ - const auto &dest ABSL_ATTRIBUTE_UNUSED( \ - found_##dest->second); /* mapped_type */ + const auto &dest [[maybe_unused]] (found_##dest->second); /* mapped_type */ // Assert that container is not empty, and reference its first element. // Works on any container type with .begin(). @@ -103,7 +102,7 @@ << "No symbol at \"" << key << "\" in " << ScopePathPrinter{scope}; \ EXPECT_EQ(found_##dest->first, key); \ const SymbolTableNode &dest(found_##dest->second); \ - const SymbolInfo &dest##_info ABSL_ATTRIBUTE_UNUSED(dest.Value()) + const SymbolInfo &dest##_info [[maybe_unused]] (dest.Value()) // For SymbolInfo::references_map_view_type only: Assert that there is exactly // one element at 'key' in 'map' and assign it to 'dest' (DependentReferences).
diff --git a/verible/verilog/analysis/verilog-equivalence.cc b/verible/verilog/analysis/verilog-equivalence.cc index f8a47d0..d5c12bea 100644 --- a/verible/verilog/analysis/verilog-equivalence.cc +++ b/verible/verilog/analysis/verilog-equivalence.cc
@@ -89,6 +89,26 @@ return IsUnlexed(verilog_tokentype(token.token_enum())); } +// True when left/right differ only because surrounding whitespace changed +// token classification (e.g. MacroCallCloseToEndLine vs ')', or +// MacroIdentifier vs MacroIdItem with unchanged spelling). +static bool TokensAreWhitespaceDependentFormatEquivalent( + const TokenInfo &left, const TokenInfo &right) { + if ((left.token_enum() == verilog_tokentype::MacroCallCloseToEndLine && + right.text() == ")") || + (right.token_enum() == verilog_tokentype::MacroCallCloseToEndLine && + left.text() == ")")) { + return true; + } + const auto is_line_ending_macro = [](int token_enum) { + return token_enum == verilog_tokentype::MacroIdentifier || + token_enum == verilog_tokentype::MacroIdItem; + }; + return is_line_ending_macro(left.token_enum()) && + is_line_ending_macro(right.token_enum()) && + left.text() == right.text(); +} + DiffStatus VerilogLexicallyEquivalent( std::string_view left, std::string_view right, const std::function<bool(const verible::TokenInfo &)> &remove_predicate, @@ -167,11 +187,11 @@ DiffStatus diff_status = DiffStatus::kEquivalent; auto recursive_comparator = [&](const TokenSequence::const_iterator l, const TokenSequence::const_iterator r) { + // Some token enums differ only by surrounding whitespace (e.g. whether a + // macro or ')' ends a line). Treat those pairs as matching enums when the + // spelling is unchanged so FormatEquivalent tolerates re-wrapping. if (l->token_enum() != r->token_enum() && - !((l->token_enum() == verilog_tokentype::MacroCallCloseToEndLine && - r->text() == ")") || - (r->token_enum() == verilog_tokentype::MacroCallCloseToEndLine && - l->text() == ")"))) { + !TokensAreWhitespaceDependentFormatEquivalent(*l, *r)) { if (errstream != nullptr) { *errstream << "Mismatched token enums. got: "; token_printer(*l, *errstream); @@ -250,12 +270,7 @@ return IsWhitespace(verilog_tokentype(t.token_enum())); }, [=](const TokenInfo &l, const TokenInfo &r) { - // MacroCallCloseToEndLine should be considered equivalent to ')', as - // they are whitespace dependant - if (((r.token_enum() == verilog_tokentype::MacroCallCloseToEndLine) && - (l.text() == ")")) || - ((l.token_enum() == verilog_tokentype::MacroCallCloseToEndLine) && - (r.text() == ")"))) { + if (TokensAreWhitespaceDependentFormatEquivalent(l, r)) { return true; } return l.EquivalentWithoutLocation(r);
diff --git a/verible/verilog/analysis/verilog-equivalence_test.cc b/verible/verilog/analysis/verilog-equivalence_test.cc index 90b0ee1..1cb9436 100644 --- a/verible/verilog/analysis/verilog-equivalence_test.cc +++ b/verible/verilog/analysis/verilog-equivalence_test.cc
@@ -255,6 +255,21 @@ } } +// MacroIdentifier vs MacroIdItem depends on whether the macro ends the line. +TEST(FormatEquivalentTest, EquivalenceOfMacroIdentifierAndMacroIdItem) { + const char *kSameSpelling[] = { + "assign x = f(`TOKEN);\n", + "assign x = f(\n`TOKEN\n);\n", + }; + ExpectCompareWithErrstream(FormatEquivalent, DiffStatus::kEquivalent, + kSameSpelling[0], kSameSpelling[1]); + + // Different macro names remain different. + ExpectCompareWithErrstream(FormatEquivalent, DiffStatus::kDifferent, + "assign x = f(`TOKEN);\n", + "assign x = f(`OTHER);\n"); +} + TEST(FormatEquivalentTest, DiagnosticMismatch) { const char *kTestCases[] = { "module foo;\n",
diff --git a/verible/verilog/formatting/BUILD b/verible/verilog/formatting/BUILD index 6150594..eb089df 100644 --- a/verible/verilog/formatting/BUILD +++ b/verible/verilog/formatting/BUILD
@@ -163,7 +163,6 @@ "//verible/common/util:expandable-tree-view", "//verible/common/util:interval", "//verible/common/util:interval-set", - "//verible/common/util:iterator-range", "//verible/common/util:logging", "//verible/common/util:spacer", "//verible/common/util:tree-operations", @@ -175,7 +174,6 @@ "//verible/verilog/analysis:verilog-equivalence", "//verible/verilog/parser:verilog-token-enum", "//verible/verilog/preprocessor:verilog-preprocess", - "@abseil-cpp//absl/base:core_headers", "@abseil-cpp//absl/log:die_if_null", "@abseil-cpp//absl/status", "@abseil-cpp//absl/status:statusor", @@ -183,28 +181,91 @@ ], ) -cc_test( - name = "formatter_test", - srcs = ["formatter_test.cc"], +cc_library( + name = "formatter-test-utils", + testonly = True, + hdrs = ["formatter-test-utils.h"], deps = [ ":format-style", ":formatter", - "//verible/common/formatting:align", - "//verible/common/formatting:basic-format-style", - "//verible/common/strings:display-utils", - "//verible/common/strings:position", - "//verible/common/text:text-structure", - "//verible/common/util:interval", "//verible/common/util:logging", - "//verible/verilog/analysis:verilog-analyzer", - "@abseil-cpp//absl/log:die_if_null", - "@abseil-cpp//absl/status", - "@abseil-cpp//absl/strings", "@googletest//:gtest", - "@googletest//:gtest_main", ], ) +_FORMATTER_E2E_TEST_DEPS = [ + ":format-style", + ":formatter", + ":formatter-test-utils", + "//verible/common/formatting:align", + "//verible/common/formatting:basic-format-style", + "//verible/common/strings:display-utils", + "//verible/common/strings:position", + "//verible/common/text:text-structure", + "//verible/common/util:interval", + "//verible/common/util:logging", + "//verible/verilog/analysis:verilog-analyzer", + "@abseil-cpp//absl/log:die_if_null", + "@abseil-cpp//absl/status", + "@abseil-cpp//absl/strings", + "@googletest//:gtest", + "@googletest//:gtest_main", +] + +cc_test( + name = "formatter_test", + srcs = ["formatter_test.cc"], + deps = _FORMATTER_E2E_TEST_DEPS, +) + +cc_test( + name = "formatter_macro_test", + srcs = ["formatter_macro_test.cc"], + deps = _FORMATTER_E2E_TEST_DEPS, +) + +cc_test( + name = "formatter_module_test", + srcs = ["formatter_module_test.cc"], + deps = _FORMATTER_E2E_TEST_DEPS, +) + +cc_test( + name = "formatter_class_package_test", + srcs = ["formatter_class_package_test.cc"], + deps = _FORMATTER_E2E_TEST_DEPS, +) + +cc_test( + name = "formatter_function_task_test", + srcs = ["formatter_function_task_test.cc"], + deps = _FORMATTER_E2E_TEST_DEPS, +) + +cc_test( + name = "formatter_align_test", + srcs = ["formatter_align_test.cc"], + deps = _FORMATTER_E2E_TEST_DEPS, +) + +cc_test( + name = "formatter_wrap_style_test", + srcs = ["formatter_wrap_style_test.cc"], + deps = _FORMATTER_E2E_TEST_DEPS, +) + +cc_test( + name = "formatter_disable_test", + srcs = ["formatter_disable_test.cc"], + deps = _FORMATTER_E2E_TEST_DEPS, +) + +cc_test( + name = "formatter_issue_regression_test", + srcs = ["formatter_issue_regression_test.cc"], + deps = _FORMATTER_E2E_TEST_DEPS, +) + cc_test( name = "formatter-tuning_test", srcs = ["formatter-tuning_test.cc"],
diff --git a/verible/verilog/formatting/README.md b/verible/verilog/formatting/README.md index 6f815bf..03b6f5e 100644 --- a/verible/verilog/formatting/README.md +++ b/verible/verilog/formatting/README.md
@@ -16,7 +16,23 @@ Below is a quick summary of the major components. [formatter.h](formatter.h) contains the top-level entry point into the -formatter. Text-in-text-out tests are in [formatter_test.cc](formatter_test.cc). +formatter. Text-in-text-out tests are split by concern to reduce merge +conflicts: + +- [formatter_test.cc](formatter_test.cc) — core smoke / `VerifyFormatting` +- [formatter_macro_test.cc](formatter_macro_test.cc) — preprocessor, `` `uvm ``, directives +- [formatter_module_test.cc](formatter_module_test.cc) — modules, ports, nets, expressions +- [formatter_class_package_test.cc](formatter_class_package_test.cc) — classes, packages, constraints +- [formatter_function_task_test.cc](formatter_function_task_test.cc) — functions, tasks, properties +- [formatter_align_test.cc](formatter_align_test.cc) — tabular / param alignment +- [formatter_wrap_style_test.cc](formatter_wrap_style_test.cc) — wrap/indent options, diagnostics +- [formatter_disable_test.cc](formatter_disable_test.cc) — `verilog_format` on/off +- [formatter_issue_regression_test.cc](formatter_issue_regression_test.cc) — GitHub issue regressions +- Shared helpers: [formatter-test-utils.h](formatter-test-utils.h) + +**New GitHub-issue formatter regressions belong in +`formatter_issue_regression_test.cc` only** (do not append them to +`formatter_test.cc`). [FormatStyle](format_style.h) defines ways in which formatting can be configured.
diff --git a/verible/verilog/formatting/format-style-init.cc b/verible/verilog/formatting/format-style-init.cc index 2dde818..a6d010b 100644 --- a/verible/verilog/formatting/format-style-init.cc +++ b/verible/verilog/formatting/format-style-init.cc
@@ -140,6 +140,13 @@ "Use compact binary expressions inside indexing / bit selection " "operators"); +ABSL_FLAG(bool, class_parameter_space, false, + "If true, keep/insert a space before '#' in a class" + "parameterized typedef, e.g. \"typedef my_class #(.P(P)) " + "my_class_t;\". If false (default), no space is inserted, " + "matching the convention used for IEEE parameterized class " + "instantiations, e.g. \"type#(params...)::method(...)\"."); + ABSL_FLAG(bool, wrap_end_else_clauses, false, "Split end and else keywords into separate lines"); @@ -197,6 +204,7 @@ STYLE_FROM_FLAG(try_wrap_long_lines); STYLE_FROM_FLAG(expand_coverpoints); STYLE_FROM_FLAG(compact_indexing_and_selections); + STYLE_FROM_FLAG(class_parameter_space); STYLE_FROM_FLAG(wrap_end_else_clauses); STYLE_FROM_FLAG(alignment_group_boundary);
diff --git a/verible/verilog/formatting/format-style.h b/verible/verilog/formatting/format-style.h index 2fad329..55347c5 100644 --- a/verible/verilog/formatting/format-style.h +++ b/verible/verilog/formatting/format-style.h
@@ -146,6 +146,9 @@ // Compact binary expressions inside indexing / bit selection operators bool compact_indexing_and_selections = true; + // Keep/insert a space before '#' in a parameterized class typedef + bool class_parameter_space = false; + // Split with a \n end and else clauses bool wrap_end_else_clauses = false;
diff --git a/verible/verilog/formatting/formatter-test-utils.h b/verible/verilog/formatting/formatter-test-utils.h new file mode 100644 index 0000000..0be6382 --- /dev/null +++ b/verible/verilog/formatting/formatter-test-utils.h
@@ -0,0 +1,69 @@ +// Copyright 2017-2026 The Verible Authors. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Shared helpers for formatter end-to-end tests. +// Penalty-sensitive cases belong in formatter-tuning_test.cc. + +#ifndef VERIBLE_VERILOG_FORMATTING_FORMATTER_TEST_UTILS_H_ +#define VERIBLE_VERILOG_FORMATTING_FORMATTER_TEST_UTILS_H_ + +#include <sstream> +#include <string_view> + +#include "gtest/gtest.h" +#include "verible/common/util/logging.h" +#include "verible/verilog/formatting/format-style.h" +#include "verible/verilog/formatting/formatter.h" + +#undef EXPECT_OK +#define EXPECT_OK(value) EXPECT_TRUE((value).ok()) + +#undef ASSERT_OK +#define ASSERT_OK(value) ASSERT_TRUE((value).ok()) + +namespace verilog { +namespace formatter { + +struct FormatterTestCase { + std::string_view input; + std::string_view expected; +}; + +// Runs FormatVerilog on each case and checks status + exact expected output. +template <typename CaseRange> +void RunFormatterTestCases(const FormatStyle &style, const CaseRange &cases) { + for (const auto &test_case : cases) { + VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; + std::ostringstream stream; + const auto status = + FormatVerilog(test_case.input, "<filename>", style, stream); + EXPECT_OK(status) << status.message(); + EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; + } +} + +// Convenience: column_limit 40 / indent 2 / wrap 4 — the default E2E style. +template <typename CaseRange> +void RunFormatterTestCases40(const CaseRange &cases) { + FormatStyle style; + style.column_limit = 40; + style.indentation_spaces = 2; + style.wrap_spaces = 4; + RunFormatterTestCases(style, cases); +} + +} // namespace formatter +} // namespace verilog + +#endif // VERIBLE_VERILOG_FORMATTING_FORMATTER_TEST_UTILS_H_
diff --git a/verible/verilog/formatting/formatter.cc b/verible/verilog/formatting/formatter.cc index 9893b60..9bd3dd2 100644 --- a/verible/verilog/formatting/formatter.cc +++ b/verible/verilog/formatting/formatter.cc
@@ -26,7 +26,6 @@ #include <string_view> #include <vector> -#include "absl/base/attributes.h" #include "absl/log/die_if_null.h" #include "absl/status/status.h" #include "absl/status/statusor.h" @@ -50,7 +49,6 @@ #include "verible/common/util/expandable-tree-view.h" #include "verible/common/util/interval-set.h" #include "verible/common/util/interval.h" -#include "verible/common/util/iterator-range.h" #include "verible/common/util/logging.h" #include "verible/common/util/spacer.h" #include "verible/common/util/tree-operations.h" @@ -749,15 +747,24 @@ case verible::SpacingDecision::kPreserve: { if (token.before.preserved_space_start != verible::string_view_null_iterator()) { - *column += token.OriginalLeadingSpaces().length(); + const std::string_view leading = token.OriginalLeadingSpaces(); + const auto last_nl = leading.find_last_of('\n'); + if (last_nl == std::string_view::npos) { + *column += leading.length(); + } else { + // Reset column after the last newline, same as FormattedToken + // emit (GitHub issue 2542). + *column = static_cast<int>(leading.length() - last_nl - 1); + } } else { *column += token.before.spaces; } break; } case verible::SpacingDecision::kWrap: - *column = 0; - ABSL_FALLTHROUGH_INTENDED; + // Newline then only the wrap indent (same as FormattedToken emit). + *column = token.before.spaces; + break; case verible::SpacingDecision::kAlign: case verible::SpacingDecision::kAppend: *column += token.before.spaces; @@ -766,6 +773,15 @@ } static int CalculateEolCommentColumn(const verible::FormattedExcerpt &line) { + // Compute the starting column of the trailing EOL comment the same way + // FormattedExcerpt::FormattedText emits spaces, including: + // * wrap indents (SpacingDecision::kWrap), and + // * preserved leading whitespace that may contain newlines (common when + // an original line break is kept). Counting those newlines as width + // made continuation comments land on the wrong column and fail to + // converge on re-format (GitHub issue 2542). + if (line.Tokens().empty()) return 0; + int column = 0; const auto &front = line.Tokens().front(); @@ -777,12 +793,16 @@ } column += front.token->text().length(); - for (const auto &ftoken : verible::make_range(line.Tokens().begin() + 1, - line.Tokens().end() - 1)) { + const auto &tokens = line.Tokens(); + for (size_t i = 1; i < tokens.size(); ++i) { + const auto &ftoken = tokens[i]; AdjustColumnUsingTokenSpacing(ftoken, &column); - column += ftoken.token->text().length(); + // Do not add the last token's length: that is the EOL comment whose + // starting column we want. + if (i + 1 < tokens.size()) { + column += ftoken.token->text().length(); + } } - AdjustColumnUsingTokenSpacing(line.Tokens().back(), &column); CHECK_GE(column, 0); return column;
diff --git a/verible/verilog/formatting/formatter_align_test.cc b/verible/verilog/formatting/formatter_align_test.cc new file mode 100644 index 0000000..affb5a7 --- /dev/null +++ b/verible/verilog/formatting/formatter_align_test.cc
@@ -0,0 +1,5066 @@ +// Copyright 2017-2026 The Verible Authors. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Test cases in this file should be *insensitive* to wrapping penalties. +// Penalty-sensitive tests belong in formatter-tuning_test.cc. + +#include <sstream> +#include <string_view> + +#include "gtest/gtest.h" +#include "verible/common/formatting/align.h" +#include "verible/common/util/logging.h" +#include "verible/verilog/formatting/format-style.h" +#include "verible/verilog/formatting/formatter-test-utils.h" +#include "verible/verilog/formatting/formatter.h" + +namespace verilog { +namespace formatter { +namespace { + +using verible::AlignmentPolicy; + +static constexpr FormatterTestCase kAlignFormatterTestCases[] = { + // module instantiation named ports tabular alignment + //{// module instantiation with no port, only comments + // "module m;\n" + // "foo bar(\n" + // "\t//comment1\n" + // "//comment2\n" + // ");\n" + // "endmodule\n", + // "module m;\n" + // " foo bar (\n" + // " //comment1\n" + // " //comment2\n" + // " );\n" + // "endmodule\n" + //}, + {// all named ports + "module m;\n" + "foo bar(.a(a), .aa(aa), .aaa(aaa));\n" + "endmodule\n", + "module m;\n" + " foo bar (\n" + " .a (a),\n" + " .aa (aa),\n" + " .aaa(aaa)\n" + " );\n" + "endmodule\n"}, + {// named ports left unconnected + "module m;\n" + "foo bar(.a(), .aa(), .aaa());\n" + "endmodule\n", + "module m;\n" + " foo bar (\n" + " .a (),\n" + " .aa (),\n" + " .aaa()\n" + " );\n" + "endmodule\n"}, + {// multiple named ports groups separated by blank line + "module m;\n" + "foo bar(.a(a), .aaa(aaa),\n\n .b(b), .bbbbbb(bbbbb));\n" + "endmodule\n", + "module m;\n" + " foo bar (\n" + " .a (a),\n" + " .aaa(aaa),\n" + "\n" + " .b (b),\n" + " .bbbbbb(bbbbb)\n" + " );\n" + "endmodule\n"}, + {// named ports with concatenation + "module m;\n" + "foo bar(.a(a), .aaa({a,b,c}));\n" + "endmodule\n", + "module m;\n" + " foo bar (\n" + " .a (a),\n" + " .aaa({a, b, c})\n" + " );\n" + "endmodule\n"}, + {// name ports with slices + "module m;\n" + "foo bar(.a(a), .aaa(q[r:s]));\n" + "endmodule\n", + "module m;\n" + " foo bar (\n" + " .a (a),\n" + " .aaa(q[r:s])\n" + " );\n" + "endmodule\n"}, + {// named ports with pre-proc directives + "module m;\n" + "foo bar(.a(a), `ifdef MACRO .aa(aa), `endif .aaa(aaa));\n" + "endmodule\n", + "module m;\n" + " foo bar (\n" + " .a (a),\n" + "`ifdef MACRO\n" + " .aa (aa),\n" + "`endif\n" + " .aaa(aaa)\n" + " );\n" + "endmodule\n"}, + {// named ports with macros + "module m;\n" + "foo bar(.a(a), .aa(aa[`RANGE]), .aaa(aaa));\n" + "endmodule\n", + "module m;\n" + " foo bar (\n" + " .a (a),\n" + " .aa (aa[`RANGE]),\n" + " .aaa(aaa)\n" + " );\n" + "endmodule\n"}, + {"module m;\n" + "foo bar(.a(a), .AA, .aaa(aaa));\n" + "endmodule\n", + "module m;\n" + " foo bar (\n" + " .a (a),\n" + " .AA,\n" + " .aaa(aaa)\n" + " );\n" + "endmodule\n"}, + {// name ports with comments + "module m;\n" + "foo bar(.a(a), .aa(aa)/*comment*/, .aaa(aaa));\n" + "endmodule\n", + "module m;\n" + " foo bar (\n" + " .a (a),\n" + " .aa (aa) /*comment*/,\n" + " .aaa(aaa)\n" + " );\n" + "endmodule\n"}, + {"module m;\n" + "foo bar(.a(a),//comment1\n .aaa(aaa)//comment2\n);\n" + "endmodule\n", + "module m;\n" + " foo bar (\n" + " .a (a), //comment1\n" + " .aaa(aaa) //comment2\n" + " );\n" + "endmodule\n"}, + {"module m;\n" + "foo bar(.a(a),\n" + " //.aa(aa),\n" + ".aaa(aaa));\n" + "endmodule\n", + "module m;\n" + " foo bar (\n" + " .a (a),\n" + " //.aa(aa),\n" + " .aaa(aaa)\n" + " );\n" + "endmodule\n"}, + {"module m;\n" + "foo bar(\n" + ".a(a) //comment1\n" + ", .aaa(aaa) //comment2\n" + ") //comment3\n" + ";\n" + "endmodule\n", + "module m;\n" + " foo bar (\n" + " .a (a) //comment1\n" + " , .aaa(aaa) //comment2\n" + " ) //comment3\n" + " ;\n" + "endmodule\n"}, + {// module instantiation with all implicit connections + "module m;\n" + "foo bar(.a, .aa, .aaaaa);\n" + "endmodule\n", + "module m;\n" + " foo bar (\n" + " .a,\n" + " .aa,\n" + " .aaaaa\n" + " );\n" + "endmodule\n"}, + {// named ports corssed with implicit connections + "module m;\n" + "foo bar(.a(a), .aa, .aaaaa(aaaaa));\n" + "endmodule\n", + "module m;\n" + " foo bar (\n" + " .a (a),\n" + " .aa,\n" + " .aaaaa(aaaaa)\n" + " );\n" + "endmodule\n"}, + {// named ports corssed with wildcard connections + "module m;\n" + "foo bar(.a(a), .aaa(aaa), .*);\n" + "endmodule\n", + "module m;\n" + " foo bar (\n" + " .a (a),\n" + " .aaa(aaa),\n" + " .*\n" + " );\n" + "endmodule\n"}, + {"module m;\n" + "foo bar(.a(a), .aa(aa), .* , .aaa(aaa));\n" + "endmodule\n", + "module m;\n" + " foo bar (\n" + " .a (a),\n" + " .aa (aa),\n" + " .*,\n" + " .aaa(aaa)\n" + " );\n" + "endmodule\n"}, + + // Parameterized data types, declarations inside #() tabular alignment + {// parameterized module with 'list_of_param_assignments' + "module foo #(A = 2, AA = 22, AAA = 222);\n" + "endmodule\n", + "module foo #(\n" + " A = 2,\n" + " AA = 22,\n" + " AAA = 222\n" + ");\n" + "endmodule\n"}, + {// parameterized module with 'parameter_declaration' + "module foo #(parameter int a = 2, parameter int aa = 22);\n" + "endmodule\n", + "module foo #(\n" + " parameter int a = 2,\n" + " parameter int aa = 22\n" + ");\n" + "endmodule\n"}, + {// parameterized module with 'parameter_declaration' and comments + "module foo #(//comment\nparameter int a = 2, parameter int aa = 22);\n" + "endmodule\n", + "module foo #( //comment\n" + " parameter int a = 2,\n" + " parameter int aa = 22\n" + ");\n" + "endmodule\n"}, + {// parameterized module with 'parameter_declaration' and trailing comments + "module foo #(parameter int a = 2,//comment\n parameter int aa = 22);\n" + "endmodule\n", + "module foo #(\n" + " parameter int a = 2, //comment\n" + " parameter int aa = 22\n" + ");\n" + "endmodule\n"}, + {// parameterized module with 'parameter_declaration' and pre-proc + "module foo #(parameter int a = 2,\n" + "`ifdef MACRO parameter int aa = 22, `endif\n" + "parameter int aaa = 222);\n" + "endmodule\n", + "module foo #(\n" + " parameter int a = 2,\n" + "`ifdef MACRO\n" + " parameter int aa = 22,\n" + "`endif\n" + " parameter int aaa = 222\n" + ");\n" + "endmodule\n"}, + {// parameterized module with 'parameter_declaration' and packed dimensions + "module foo #(parameter logic [3:0] a = 2, parameter logic [30:0] aa = " + "22);\n" + "endmodule\n", + "module foo #(\n" + " parameter logic [ 3:0] a = 2,\n" + " parameter logic [30:0] aa = 22\n" + ");\n" + "endmodule\n"}, + {// parameterized module with 'parameter_declaration' and unpacked + // dimensions + "module foo #(parameter logic a[3:0] = 2, parameter logic aa [30:0] = " + "22);\n" + "endmodule\n", + "module foo #(\n" + " parameter logic a [ 3:0] = 2,\n" + " parameter logic aa[30:0] = 22\n" + ");\n" + "endmodule\n"}, + + {// parameterized module with 'local_parameter_declaration' + "module foo #(localparam int a = 2, localparam int aa = 22);\n" + "endmodule\n", + "module foo #(\n" + " localparam int a = 2,\n" + " localparam int aa = 22\n" + ");\n" + "endmodule\n"}, + {// parameterized module with 'local_parameter_declaration' and comments + "module foo #(//comment\nlocalparam int a = 2, localparam int aa = 22);\n" + "endmodule\n", + "module foo #( //comment\n" + " localparam int a = 2,\n" + " localparam int aa = 22\n" + ");\n" + "endmodule\n"}, + {// parameterized module with 'local_parameter_declaration' and trailing + // comments + "module foo #(localparam int a = 2,//comment\n localparam int aa = 22);\n" + "endmodule\n", + "module foo #(\n" + " localparam int a = 2, //comment\n" + " localparam int aa = 22\n" + ");\n" + "endmodule\n"}, + {// parameterized module with 'local_parameter_declaration' and pre-proc + "module foo #(localparam int a = 2,\n" + "`ifdef MACRO localparam int aa = 22, `endif\n" + "localparam int aaa = 222);\n" + "endmodule\n", + "module foo #(\n" + " localparam int a = 2,\n" + "`ifdef MACRO\n" + " localparam int aa = 22,\n" + "`endif\n" + " localparam int aaa = 222\n" + ");\n" + "endmodule\n"}, + {// parameterized module with 'local_parameter_declaration' and packed + // dimensions + "module foo #(localparam logic [3:0] a = 2, localparam logic [30:0] aa = " + "22);\n" + "endmodule\n", + "module foo #(\n" + " localparam logic [ 3:0] a = 2,\n" + " localparam logic [30:0] aa = 22\n" + ");\n" + "endmodule\n"}, + {// parameterized module with 'local_parameter_declaration' and unpacked + // dimensions + "module foo #(localparam logic a[3:0] = 2, localparam logic aa [30:0] = " + "22);\n" + "endmodule\n", + "module foo #(\n" + " localparam logic a [ 3:0] = 2,\n" + " localparam logic aa[30:0] = 22\n" + ");\n" + "endmodule\n"}, + + {// parameterized module with 'data_type list_of_param_assignments' + "module foo #( int a = 2, real aa = 22, longint aaa = 222);\n" + "endmodule\n", + "module foo #(\n" + " int a = 2,\n" + " real aa = 22,\n" + " longint aaa = 222\n" + ");\n" + "endmodule\n"}, + {// parameterized module with 'data_type list_of_param_assignments' and + // comments + "module foo #(//comment\nint a = 2, shortreal aa = 22, longint aaa = " + "222);\n" + "endmodule\n", + "module foo #( //comment\n" + " int a = 2,\n" + " shortreal aa = 22,\n" + " longint aaa = 222\n" + ");\n" + "endmodule\n"}, + {// parameterized module with 'data_type list_of_param_assignments' and + // trailing comments + "module foo #(int a = 2, shortreal aa = 22,//comment\n longint aaa = " + "222);\n" + "endmodule\n", + "module foo #(\n" + " int a = 2,\n" + " shortreal aa = 22, //comment\n" + " longint aaa = 222\n" + ");\n" + "endmodule\n"}, + {// parameterized module with 'data_type list_of_param_assignments' and + // pre-proc + "module foo #(int a = 2,\n" + "`ifdef MACRO shortreal aa = 22, `endif\n" + " longint aaa = 222);\n" + "endmodule\n", + "module foo #(\n" + " int a = 2,\n" + "`ifdef MACRO\n" + " shortreal aa = 22,\n" + "`endif\n" + " longint aaa = 222\n" + ");\n" + "endmodule\n"}, + {// parameterized module with 'data_type list_of_param_assignments' and + // packed dimensions + "module foo #(bit [1:0] a = 2, reg [12:0] aa = 22, logic [123:0] aaa = " + "222);\n" + "endmodule\n", + "module foo #(\n" + " bit [ 1:0] a = 2,\n" + " reg [ 12:0] aa = 22,\n" + " logic [123:0] aaa = 222\n" + ");\n" + "endmodule\n"}, + {// parameterized module with 'data_type list_of_param_assignments' and + // unpacked dimensions + "module foo #(bit a[1:0] = 2, reg aa[12:0] = 22, logic aaa [123:0] = " + "222);\n" + "endmodule\n", + "module foo #(\n" + " bit a [ 1:0] = 2,\n" + " reg aa [ 12:0] = 22,\n" + " logic aaa[123:0] = 222\n" + ");\n" + "endmodule\n"}, + {// parameterized module with 'type list_of_type_assignments' + "module foo #(type T = int, type TT = bit, type TTT= C#(logic) );\n" + "endmodule\n", + "module foo #(\n" + " type T = int,\n" + " type TT = bit,\n" + " type TTT = C#(logic)\n" + ");\n" + "endmodule\n"}, + {// parameterized module with 'type list_of_type_assignments' and comments + "module foo #(//comment\ntype T = int, type TT = bit, type TTT= C#(logic) " + ");\n" + "endmodule\n", + "module foo #( //comment\n" + " type T = int,\n" + " type TT = bit,\n" + " type TTT = C#(logic)\n" + ");\n" + "endmodule\n"}, + {// parameterized module with 'data_type list_of_param_assignments' and + // trailing comments + "module foo #(type T = int, type TT = bit, //comment\n type TTT= " + "C#(logic) );\n" + "endmodule\n", + "module foo #(\n" + " type T = int,\n" + " type TT = bit, //comment\n" + " type TTT = C#(logic)\n" + ");\n" + "endmodule\n"}, + {// parameterized module with 'data_type list_of_param_assignments' and + // pre-proc + "module foo #(type T = int,\n" + "`ifdef MACRO type TT = bit, `endif\n" + " type TTT= C#(logic));\n" + "endmodule\n", + "module foo #(\n" + " type T = int,\n" + "`ifdef MACRO\n" + " type TT = bit,\n" + "`endif\n" + " type TTT = C#(logic)\n" + ");\n" + "endmodule\n"}, + {// parameterized module with 'data_type list_of_param_assignments' and + // packed dimensions + "module foo #(type T = int [3:0], type TT = bit [250:0]);\n" + "endmodule\n", + "module foo #(\n" + " type T = int [ 3:0],\n" + " type TT = bit [250:0]\n" + ");\n" + "endmodule\n"}, + {"module foo #(type T = int, " + "A = 2, int AA = 22, parameter AAA = 222, parameter longint AAAA = 2222, " + "localparam AAAAA = 22222, localparam real AAAAAA = 222222" + ");\n" + "endmodule\n", + "module foo #(\n" + " type T = int,\n" + " A = 2,\n" + " int AA = 22,\n" + " parameter AAA = 222,\n" + " parameter longint AAAA = 2222,\n" + " localparam AAAAA = 22222,\n" + " localparam real AAAAAA = 222222\n" + ");\n" + "endmodule\n"}, + {// parameterized module with built-in data type + "module foo #(int a = 2, real abc = 2234);\n" + "endmodule\n", + "module foo #(\n" + " int a = 2,\n" + " real abc = 2234\n" + ");\n" + "endmodule\n"}, + {// parameterized module with type + "module foo #(type TYPE1 = int, type TYPE2 = boo);\n" + "endmodule\n", + "module foo #(\n" + " type TYPE1 = int,\n" + " type TYPE2 = boo\n" + ");\n" + "endmodule\n"}, + {"module foo#(localparam type TYPE1 = int, type TYPE22 = bool, parameter " + " type TYPE333 = real);\n" + "endmodule\n", + "module foo #(\n" + " localparam type TYPE1 = int,\n" + " type TYPE22 = bool,\n" + " parameter type TYPE333 = real\n" + ");\n" + "endmodule\n"}, + {// parameterized module with 'data_type list_of_param_assignments' and 1D + // packed dimensions + "module foo #(parameter type T = int [3:0], type TT = bit [123:0]);\n" + "endmodule\n", + "module foo #(\n" + " parameter type T = int [ 3:0],\n" + " type TT = bit [123:0]\n" + ");\n" + "endmodule\n"}, + {// parameterized module with 'data_type list_of_param_assignments' and 2D + // packed dimensions + "module foo #(type T = int [3:0][123:0], type TT = bit [123:0][1:0]);\n" + "endmodule\n", + "module foo #(\n" + " type T = int [ 3:0][123:0],\n" + " type TT = bit [123:0][ 1:0]\n" + ");\n" + "endmodule\n"}, + {// parametrized module with user defined data types + "module foo #(type T = my_type1_t, type TT = my_pkg::my_type2_t);\n" + "endmodule\n", + "module foo #(\n" + " type T = my_type1_t,\n" + " type TT = my_pkg::my_type2_t\n" + ");\n" + "endmodule\n"}, + + {// parameterized class with 'list_of_param_assignments' + "class foo #(A = 2, AA = 22, AAA = 222);\n" + "endclass\n", + "class foo #(\n" + " A = 2,\n" + " AA = 22,\n" + " AAA = 222\n" + ");\n" + "endclass\n"}, + {// parameterized class with 'parameter_declaration' + "class foo #(parameter int a = 2, parameter int aa = 22);\n" + "endclass\n", + "class foo #(\n" + " parameter int a = 2,\n" + " parameter int aa = 22\n" + ");\n" + "endclass\n"}, + {// parameterized class with 'parameter_declaration' and comments + "class foo #(//comment\nparameter int a = 2, parameter int aa = 22);\n" + "endclass\n", + "class foo #( //comment\n" + " parameter int a = 2,\n" + " parameter int aa = 22\n" + ");\n" + "endclass\n"}, + {// parameterized class with 'parameter_declaration' and trailing comments + "class foo #(parameter int a = 2,//comment\n parameter int aa = 22);\n" + "endclass\n", + "class foo #(\n" + " parameter int a = 2, //comment\n" + " parameter int aa = 22\n" + ");\n" + "endclass\n"}, + {// parameterized class with 'parameter_declaration' and pre-proc + "class foo #(parameter int a = 2,\n" + "`ifdef MACRO parameter int aa = 22, `endif\n" + "parameter int aaa = 222);\n" + "endclass\n", + "class foo #(\n" + " parameter int a = 2,\n" + "`ifdef MACRO\n" + " parameter int aa = 22,\n" + "`endif\n" + " parameter int aaa = 222\n" + ");\n" + "endclass\n"}, + {// parameterized class with 'parameter_declaration' and packed dimensions + "class foo #(parameter logic [3:0] a = 2, parameter logic [30:0] aa = " + "22);\n" + "endclass\n", + "class foo #(\n" + " parameter logic [ 3:0] a = 2,\n" + " parameter logic [30:0] aa = 22\n" + ");\n" + "endclass\n"}, + {// parameterized class with 'parameter_declaration' and unpacked dimensions + "class foo #(parameter logic a[3:0] = 2, parameter logic aa [30:0] = " + "22);\n" + "endclass\n", + "class foo #(\n" + " parameter logic a [ 3:0] = 2,\n" + " parameter logic aa[30:0] = 22\n" + ");\n" + "endclass\n"}, + + {// parameterized class with 'local_parameter_declaration' + "class foo #(localparam int a = 2, localparam int aa = 22);\n" + "endclass\n", + "class foo #(\n" + " localparam int a = 2,\n" + " localparam int aa = 22\n" + ");\n" + "endclass\n"}, + {// parameterized class with 'local_parameter_declaration' and comments + "class foo #(//comment\nlocalparam int a = 2, localparam int aa = 22);\n" + "endclass\n", + "class foo #( //comment\n" + " localparam int a = 2,\n" + " localparam int aa = 22\n" + ");\n" + "endclass\n"}, + {// parameterized class with 'local_parameter_declaration' and trailing + // comments + "class foo #(localparam int a = 2,//comment\n localparam int aa = 22);\n" + "endclass\n", + "class foo #(\n" + " localparam int a = 2, //comment\n" + " localparam int aa = 22\n" + ");\n" + "endclass\n"}, + {// parameterized class with 'local_parameter_declaration' and pre-proc + "class foo #(localparam int a = 2,\n" + "`ifdef MACRO localparam int aa = 22, `endif\n" + "localparam int aaa = 222);\n" + "endclass\n", + "class foo #(\n" + " localparam int a = 2,\n" + "`ifdef MACRO\n" + " localparam int aa = 22,\n" + "`endif\n" + " localparam int aaa = 222\n" + ");\n" + "endclass\n"}, + {// parameterized class with 'local_parameter_declaration' and packed + // dimensions + "class foo #(localparam logic [3:0] a = 2, localparam logic [30:0] aa = " + "22);\n" + "endclass\n", + "class foo #(\n" + " localparam logic [ 3:0] a = 2,\n" + " localparam logic [30:0] aa = 22\n" + ");\n" + "endclass\n"}, + {// parameterized class with 'local_parameter_declaration' and unpacked + // dimensions + "class foo #(localparam logic a[3:0] = 2, localparam logic aa [30:0] = " + "22);\n" + "endclass\n", + "class foo #(\n" + " localparam logic a [ 3:0] = 2,\n" + " localparam logic aa[30:0] = 22\n" + ");\n" + "endclass\n"}, + {// parameterized class with 'data_type list_of_param_assignments' + "class foo #( int a = 2, real aa = 22, longint aaa = 222);\n" + "endclass\n", + "class foo #(\n" + " int a = 2,\n" + " real aa = 22,\n" + " longint aaa = 222\n" + ");\n" + "endclass\n"}, + {// parameterized class with 'data_type list_of_param_assignments' and + // comments + "class foo #(//comment\nint a = 2, shortreal aa = 22, longint aaa = " + "222);\n" + "endclass\n", + "class foo #( //comment\n" + " int a = 2,\n" + " shortreal aa = 22,\n" + " longint aaa = 222\n" + ");\n" + "endclass\n"}, + {// parameterized class with 'data_type list_of_param_assignments' and + // trailing comments + "class foo #(int a = 2, shortreal aa = 22,//comment\n longint aaa = " + "222);\n" + "endclass\n", + "class foo #(\n" + " int a = 2,\n" + " shortreal aa = 22, //comment\n" + " longint aaa = 222\n" + ");\n" + "endclass\n"}, + {// parameterized class with 'data_type list_of_param_assignments' and + // pre-proc + "class foo #(int a = 2,\n" + "`ifdef MACRO shortreal aa = 22, `endif\n" + " longint aaa = 222);\n" + "endclass\n", + "class foo #(\n" + " int a = 2,\n" + "`ifdef MACRO\n" + " shortreal aa = 22,\n" + "`endif\n" + " longint aaa = 222\n" + ");\n" + "endclass\n"}, + {// parameterized class with 'data_type list_of_param_assignments' and + // packed dimensions + "class foo #(bit [1:0] a = 2, reg [12:0] aa = 22, logic [123:0] aaa = " + "222);\n" + "endclass\n", + "class foo #(\n" + " bit [ 1:0] a = 2,\n" + " reg [ 12:0] aa = 22,\n" + " logic [123:0] aaa = 222\n" + ");\n" + "endclass\n"}, + {// parameterized class with 'data_type list_of_param_assignments' and + // unpacked dimensions + "class foo #(bit a[1:0] = 2, reg aa[12:0] = 22, logic aaa [123:0] = " + "222);\n" + "endclass\n", + "class foo #(\n" + " bit a [ 1:0] = 2,\n" + " reg aa [ 12:0] = 22,\n" + " logic aaa[123:0] = 222\n" + ");\n" + "endclass\n"}, + {// parameterized class with 'type list_of_type_assignments' + "class foo #(type T = int, type TT = bit, type TTT= C#(logic) );\n" + "endclass\n", + "class foo #(\n" + " type T = int,\n" + " type TT = bit,\n" + " type TTT = C#(logic)\n" + ");\n" + "endclass\n"}, + {// parameterized class with 'type list_of_type_assignments' and comments + "class foo #(//comment\ntype T = int, type TT = bit, type TTT= C#(logic) " + ");\n" + "endclass\n", + "class foo #( //comment\n" + " type T = int,\n" + " type TT = bit,\n" + " type TTT = C#(logic)\n" + ");\n" + "endclass\n"}, + {// parameterized class with 'data_type list_of_param_assignments' and + // trailing comments + "class foo #(type T = int, type TT = bit, //comment\n type TTT= C#(logic) " + ");\n" + "endclass\n", + "class foo #(\n" + " type T = int,\n" + " type TT = bit, //comment\n" + " type TTT = C#(logic)\n" + ");\n" + "endclass\n"}, + {// parameterized class with 'data_type list_of_param_assignments' and + // pre-proc + "class foo #(type T = int,\n" + "`ifdef MACRO type TT = bit, `endif\n" + " type TTT= C#(logic));\n" + "endclass\n", + "class foo #(\n" + " type T = int,\n" + "`ifdef MACRO\n" + " type TT = bit,\n" + "`endif\n" + " type TTT = C#(logic)\n" + ");\n" + "endclass\n"}, + {// parameterized class with 'data_type list_of_param_assignments' and + // packed dimensions + "class foo #(type T = int [3:0], type TT = bit [250:0]);\n" + "endclass\n", + "class foo #(\n" + " type T = int [ 3:0],\n" + " type TT = bit [250:0]\n" + ");\n" + "endclass\n"}, + {"class foo #(type T = int, " + "A = 2, int AA = 22, parameter AAA = 222, parameter longint AAAA = 2222, " + "localparam AAAAA = 22222, localparam real AAAAAA = 222222" + ");\n" + "endclass\n", + "class foo #(\n" + " type T = int,\n" + " A = 2,\n" + " int AA = 22,\n" + " parameter AAA = 222,\n" + " parameter longint AAAA = 2222,\n" + " localparam AAAAA = 22222,\n" + " localparam real AAAAAA = 222222\n" + ");\n" + "endclass\n"}, + {// parameterized class with built-in data type + "class foo #(int a = 2, real abc = 2234);\n" + "endclass\n", + "class foo #(\n" + " int a = 2,\n" + " real abc = 2234\n" + ");\n" + "endclass\n"}, + {// parameterized class with type + "class foo #(type TYPE1 = int, type TYPE2 = boo);\n" + "endclass\n", + "class foo #(\n" + " type TYPE1 = int,\n" + " type TYPE2 = boo\n" + ");\n" + "endclass\n"}, + {"class foo#(localparam type TYPE1 = int, type TYPE22 = bool, parameter " + "type TYPE333 = real);\n" + "endclass\n", + "class foo #(\n" + " localparam type TYPE1 = int,\n" + " type TYPE22 = bool,\n" + " parameter type TYPE333 = real\n" + ");\n" + "endclass\n"}, + {// parameterized class with 'data_type list_of_param_assignments' and 1D + // packed dimensions + "class foo #(parameter type T = int [3:0], type TT = bit [123:0]);\n" + "endclass\n", + "class foo #(\n" + " parameter type T = int [ 3:0],\n" + " type TT = bit [123:0]\n" + ");\n" + "endclass\n"}, + {// parameterized class with 'data_type list_of_param_assignments' and 2D + // packed dimensions + "class foo #(type T = int [3:0][123:0], type TT = bit [123:0][1:0]);\n" + "endclass\n", + "class foo #(\n" + " type T = int [ 3:0][123:0],\n" + " type TT = bit [123:0][ 1:0]\n" + ");\n" + "endclass\n"}, + {// parametrized class with user defined data types + "class foo #(type T = my_type1_t, type TT = my_pkg::my_type2_t);\n" + "endclass\n", + "class foo #(\n" + " type T = my_type1_t,\n" + " type TT = my_pkg::my_type2_t\n" + ");\n" + "endclass\n"}, + + {// parameterized interface with 'local_parameter_declaration' + "interface foo #(localparam int a = 2, localparam int aa = 22);\n" + "endinterface\n", + "interface foo #(\n" + " localparam int a = 2,\n" + " localparam int aa = 22\n" + ");\n" + "endinterface\n"}, + {// parameterized interface with 'local_parameter_declaration' and comments + "interface foo #(//comment\nlocalparam int a = 2, localparam int aa = " + "22);\n" + "endinterface\n", + "interface foo #( //comment\n" + " localparam int a = 2,\n" + " localparam int aa = 22\n" + ");\n" + "endinterface\n"}, + {// parameterized interface with 'local_parameter_declaration' and trailing + // comments + "interface foo #(localparam int a = 2,//comment\n localparam int aa = " + "22);\n" + "endinterface\n", + "interface foo #(\n" + " localparam int a = 2, //comment\n" + " localparam int aa = 22\n" + ");\n" + "endinterface\n"}, + {// parameterized interface with 'local_parameter_declaration' and pre-proc + "interface foo #(localparam int a = 2,\n" + "`ifdef MACRO localparam int aa = 22, `endif\n" + "localparam int aaa = 222);\n" + "endinterface\n", + "interface foo #(\n" + " localparam int a = 2,\n" + "`ifdef MACRO\n" + " localparam int aa = 22,\n" + "`endif\n" + " localparam int aaa = 222\n" + ");\n" + "endinterface\n"}, + {// parameterized interface with 'local_parameter_declaration' and packed + // dimensions + "interface foo #(localparam logic [3:0] a = 2, localparam logic [30:0] aa " + "= 22);\n" + "endinterface\n", + "interface foo #(\n" + " localparam logic [ 3:0] a = 2,\n" + " localparam logic [30:0] aa = 22\n" + ");\n" + "endinterface\n"}, + {// parameterized interface with 'local_parameter_declaration' and unpacked + // dimensions + "interface foo #(localparam logic a[3:0] = 2, localparam logic aa [30:0] " + "= 22);\n" + "endinterface\n", + "interface foo #(\n" + " localparam logic a [ 3:0] = 2,\n" + " localparam logic aa[30:0] = 22\n" + ");\n" + "endinterface\n"}, + {// parameterized interface with 'data_type list_of_param_assignments' + "interface foo #( int a = 2, real aa = 22, longint aaa = 222);\n" + "endinterface\n", + "interface foo #(\n" + " int a = 2,\n" + " real aa = 22,\n" + " longint aaa = 222\n" + ");\n" + "endinterface\n"}, + {// parameterized interface with 'data_type list_of_param_assignments' and + // comments + "interface foo #(//comment\nint a = 2, shortreal aa = 22, longint aaa = " + "222);\n" + "endinterface\n", + "interface foo #( //comment\n" + " int a = 2,\n" + " shortreal aa = 22,\n" + " longint aaa = 222\n" + ");\n" + "endinterface\n"}, + {// parameterized interface with 'data_type list_of_param_assignments' and + // trailing comments + "interface foo #(int a = 2, shortreal aa = 22,//comment\n longint aaa = " + "222);\n" + "endinterface\n", + "interface foo #(\n" + " int a = 2,\n" + " shortreal aa = 22, //comment\n" + " longint aaa = 222\n" + ");\n" + "endinterface\n"}, + {// parameterized interface with 'data_type list_of_param_assignments' and + // pre-proc + "interface foo #(int a = 2,\n" + "`ifdef MACRO shortreal aa = 22, `endif\n" + " longint aaa = 222);\n" + "endinterface\n", + "interface foo #(\n" + " int a = 2,\n" + "`ifdef MACRO\n" + " shortreal aa = 22,\n" + "`endif\n" + " longint aaa = 222\n" + ");\n" + "endinterface\n"}, + {// parameterized interface with 'data_type list_of_param_assignments' and + // packed dimensions + "interface foo #(bit [1:0] a = 2, reg [12:0] aa = 22, logic [123:0] aaa " + "= 222);\n" + "endinterface\n", + "interface foo #(\n" + " bit [ 1:0] a = 2,\n" + " reg [ 12:0] aa = 22,\n" + " logic [123:0] aaa = 222\n" + ");\n" + "endinterface\n"}, + {// parameterized interface with 'data_type list_of_param_assignments' and + // unpacked dimensions + "interface foo #(bit a[1:0] = 2, reg aa[12:0] = 22, logic aaa [123:0] " + "= 222);\n" + "endinterface\n", + "interface foo #(\n" + " bit a [ 1:0] = 2,\n" + " reg aa [ 12:0] = 22,\n" + " logic aaa[123:0] = 222\n" + ");\n" + "endinterface\n"}, + {// parameterized interface with 'type list_of_type_assignments' + "interface foo #(type T = int, type TT = bit, type TTT= C#(logic) );\n" + "endinterface\n", + "interface foo #(\n" + " type T = int,\n" + " type TT = bit,\n" + " type TTT = C#(logic)\n" + ");\n" + "endinterface\n"}, + {// parameterized interface with 'type list_of_type_assignments' and + // comments + "interface foo #(//comment\ntype T = int, type TT = bit, type TTT= " + "C#(logic) );\n" + "endinterface\n", + "interface foo #( //comment\n" + " type T = int,\n" + " type TT = bit,\n" + " type TTT = C#(logic)\n" + ");\n" + "endinterface\n"}, + {// parameterized interface with 'data_type list_of_param_assignments' and + // trailing comments + "interface foo #(type T = int, type TT = bit, //comment\n type TTT= " + "C#(logic) );\n" + "endinterface\n", + "interface foo #(\n" + " type T = int,\n" + " type TT = bit, //comment\n" + " type TTT = C#(logic)\n" + ");\n" + "endinterface\n"}, + {// parameterized interface with 'data_type list_of_param_assignments' and + // pre-proc + "interface foo #(type T = int,\n" + "`ifdef MACRO type TT = bit, `endif\n" + " type TTT= C#(logic));\n" + "endinterface\n", + "interface foo #(\n" + " type T = int,\n" + "`ifdef MACRO\n" + " type TT = bit,\n" + "`endif\n" + " type TTT = C#(logic)\n" + ");\n" + "endinterface\n"}, + {// parameterized interface with 'data_type list_of_param_assignments' and + // packed dimensions + "interface foo #(type T = int [3:0], type TT = bit [250:0]);\n" + "endinterface\n", + "interface foo #(\n" + " type T = int [ 3:0],\n" + " type TT = bit [250:0]\n" + ");\n" + "endinterface\n"}, + {"interface foo #(type T = int, " + "A = 2, int AA = 22, parameter AAA = 222, parameter longint AAAA = 2222, " + "localparam AAAAA = 22222, localparam real AAAAAA = 222222" + ");\n" + "endinterface\n", + "interface foo #(\n" + " type T = int,\n" + " A = 2,\n" + " int AA = 22,\n" + " parameter AAA = 222,\n" + " parameter longint AAAA = 2222,\n" + " localparam AAAAA = 22222,\n" + " localparam real AAAAAA = 222222\n" + ");\n" + "endinterface\n"}, + {// parameterized interface with built-in data type + "interface foo #(int a = 2, real abc = 2234);\n" + "endinterface\n", + "interface foo #(\n" + " int a = 2,\n" + " real abc = 2234\n" + ");\n" + "endinterface\n"}, + {// parameterized interface with type + "interface foo #(type TYPE1 = int, type TYPE2 = boo);\n" + "endinterface\n", + "interface foo #(\n" + " type TYPE1 = int,\n" + " type TYPE2 = boo\n" + ");\n" + "endinterface\n"}, + {"interface foo#(localparam type TYPE1 = int, type TYPE22 = bool, " + "parameter type TYPE333 = real);\n" + "endinterface\n", + "interface foo #(\n" + " localparam type TYPE1 = int,\n" + " type TYPE22 = bool,\n" + " parameter type TYPE333 = real\n" + ");\n" + "endinterface\n"}, + {// parameterized interface with 'data_type list_of_param_assignments' and + // 1D packed dimensions + "interface foo #(parameter type T = int [3:0], type TT = bit [123:0]);\n" + "endinterface\n", + "interface foo #(\n" + " parameter type T = int [ 3:0],\n" + " type TT = bit [123:0]\n" + ");\n" + "endinterface\n"}, + {// parameterized interface with 'data_type list_of_param_assignments' and + // 2D packed dimensions + "interface foo #(type T = int [3:0][123:0], type TT = bit [123:0][1:0]);\n" + "endinterface\n", + "interface foo #(\n" + " type T = int [ 3:0][123:0],\n" + " type TT = bit [123:0][ 1:0]\n" + ");\n" + "endinterface\n"}, + {// parametrized interface with user defined data types + "interface foo #(type T = my_type1_t, type TT = my_pkg::my_type2_t);\n" + "endinterface\n", + "interface foo #(\n" + " type T = my_type1_t,\n" + " type TT = my_pkg::my_type2_t\n" + ");\n" + "endinterface\n"}, + {// wildcard import package at module header + "module foo import bar::*; (baz); endmodule\n", + "module foo\n" + " import bar::*;\n" + "(\n" + " baz\n" + ");\n" + "endmodule\n"}, + {// import package at module header + "module foo import bar::baz; (qux); endmodule\n", + "module foo\n" + " import bar::baz;\n" + "(\n" + " qux\n" + ");\n" + "endmodule\n"}, + {// wildcard import multiple packages at module header + "module foo import bar::*,baz::*; (qux); endmodule\n", + "module foo\n" + " import bar::*, baz::*;\n" + "(\n" + " qux\n" + ");\n" + "endmodule\n"}, + {// separate package import declarations in module header + "module foo import bar::*,baz::*; import q_pkg::qux; (qux); endmodule\n", + "module foo\n" + " import bar::*, baz::*;\n" + " import q_pkg::qux;\n" + "(\n" + " qux\n" + ");\n" + "endmodule\n"}, + {// import package at module header + "module foo import bar::baz; #(int p = 3)(qux); endmodule\n", + "module foo\n" + " import bar::baz;\n" + "#(\n" + " int p = 3\n" + ") (\n" + " qux\n" + ");\n" + "endmodule\n"}, + // Space between return keyword and return value + {"function int foo(logic [31:0] data); return{<<8{data}}; endfunction", + "function int foo(logic [31:0] data);\n" + " return {<<8{data}};\n" + "endfunction\n"}, + {"function int f;return(1);endfunction", + "function int f;\n" + " return (1);\n" + "endfunction\n"}, + {"function int f;return-1;endfunction", + "function int f;\n" + " return -1;\n" + "endfunction\n"}, + {"function int f ;return ! x\n;endfunction", + "function int f;\n" + " return !x;\n" + "endfunction\n"}, + {"function int f ;return ~ x\n;endfunction", + "function int f;\n" + " return ~x;\n" + "endfunction\n"}, + {"function int f ;return $x\n;endfunction", + "function int f;\n" + " return $x;\n" + "endfunction\n"}, + // String initializers + {"string a[] = {\n\"a\"\n};\n", "string a[] = {\"a\"};\n"}, + {"string abc[] = {\n\"a\",\n\"b\",\n\"c\"\n};\n", + "string abc[] = {\"a\", \"b\", \"c\"};\n"}, + {"string abc[] = {\n" + "\"a\",//\n" + "\"b\", \"c\"\n" + "};\n", + "string abc[] = {\"a\", //\n" + " \"b\",\n" + " \"c\"};\n"}, + {"string abc[] = {//\n" + "\"a\", \"b\", \"c\"" + "};\n", + "string abc[] = { //\n" + " \"a\",\n" + " \"b\",\n" + " \"c\"\n" + "};\n"}, + {"string abc[] = {\n" + "\"a\", \"b\", \"c\"//\n" + "};\n", + "string abc[] = {\"a\",\n" + " \"b\",\n" + " \"c\" //\n" + " };\n"}, + {"string abc[] = {//\n" + "\"a\",//\n" + "\"b\", \"c\"//\n" + "};\n", + "string abc[] = { //\n" + " \"a\", //\n" + " \"b\",\n" + " \"c\" //\n" + "};\n"}, + {"string abc[] = {\n" + "\"a\",\n" + "// comment\n" + "// comment\n" + "\"b\",\n" + "\"c\"\n" + "};\n", + "string abc[] = {\"a\",\n" + " // comment\n" + " // comment\n" + " \"b\",\n" + " \"c\"};\n"}, + {"string numbers[] = {\"one\", \"two\", \"three\", \"four\"};\n", + "string numbers[] = {\"one\",\n" + " \"two\",\n" + " \"three\",\n" + " \"four\"};\n"}, + {"string numbers[] = {\"one\", \"two\", THREE, \"four\"};\n", + "string numbers[] = {\n" + " \"one\", \"two\", THREE, \"four\"\n" + "};\n"}, + {"string numbers[] = {\"one\", {\"two\", \"three\"}, \"four\"};\n", + "string numbers[] = {\n" + " \"one\", {\"two\", \"three\"}, \"four\"\n" + "};\n"}, + {"string numbers[] = {\"one\", {\"two\", //\n" + "\"three\"}, \"four\"};\n", + "string numbers[] = {\n" + " \"one\",\n" + " {\n" + " \"two\", //\n" + " \"three\"\n" + " },\n" + " \"four\"\n" + "};\n"}, + {"string years[] = {\"two_thousand_nineteen\", \"two_thousand_twenty\",\n" + "\"two_thousand_twenty_one\"};\n", + // line with 3rd string would exceed column limit in unwrapped style + "string years[] = {\n" + " \"two_thousand_nineteen\",\n" + " \"two_thousand_twenty\",\n" + " \"two_thousand_twenty_one\"\n" + "};\n"}, + {"class class_name;\n" + "var_type var_name = new(\"the_string\");\n" + "endclass\n", + "class class_name;\n" + " var_type var_name = new(\"the_string\");\n" + "endclass\n"}, + + //{ // parameterized class with 'parameter_declaration' and MACRO + // "class foo #(parameter int a = 2,\n" + // "parameter int aaa = `MACRO);\n" + // "endclass\n", + // "class foo #(\n" + // " parameter int a = 2,\n" + // " parameter int aaa = `MACRO\n" + // ");\n" + // "endclass\n" + //}, + // Struct/Union alignment + {"typedef struct {\n" + "bit [3:0] first; bit [31:0] second; generic_type_name_t third;\n" + "} type_t;", + "typedef struct {\n" + " bit [3:0] first;\n" + " bit [31:0] second;\n" + " generic_type_name_t third;\n" + "} type_t;\n"}, + {"typedef union soft packed {\n" + "bit [3:0] first; bit [31:0] second; generic_type_name_t third;\n" + "} type_t;", + "typedef union soft packed {\n" + " bit [3:0] first;\n" + " bit [31:0] second;\n" + " generic_type_name_t third;\n" + "} type_t;\n"}, + {"typedef union soft {\n" + "bit [3:0] first; bit [31:0] second; generic_type_name_t third;\n" + "} type_t;", + "typedef union soft {\n" + " bit [3:0] first;\n" + " bit [31:0] second;\n" + " generic_type_name_t third;\n" + "} type_t;\n"}, + {"typedef struct {\n" + "// comment\n" + "bit [3:0] first; bit [31:0] second; generic_type_name_t third;\n" + "} type_t;", + "typedef struct {\n" + " // comment\n" + " bit [3:0] first;\n" + " bit [31:0] second;\n" + " generic_type_name_t third;\n" + "} type_t;\n"}, + {"typedef struct {\n" + "// comment 0\n" + "bit [31:0] first; // a\n" + "bit [31:0] second; // b\n" + "bit third; // c\n" + "uint fourth; // d\n" + "\n" + "// comment 1\n" + "int fifth;\n" + "// comment 2.1\n" + "// comment 2.2\n" + "uint sixth;\n" + "} timing_cfg_t;", + "typedef struct {\n" + " // comment 0\n" + " bit [31:0] first; // a\n" + " bit [31:0] second; // b\n" + " bit third; // c\n" + " uint fourth; // d\n" + "\n" + " // comment 1\n" + " int fifth;\n" + " // comment 2.1\n" + " // comment 2.2\n" + " uint sixth;\n" + "} timing_cfg_t;\n"}, + {"typedef struct {\n" + "// comment\n" + "rand int r;\n" + "int a;\n" + "int aa = 0;\n" + "int aaa = 1; // comment\n" + "foo#(bar) z;\n" + "int [x:y] zz; // comment\n" + "int zzz[a:b];\n" + "} type_t;", + "typedef struct {\n" + " // comment\n" + " rand int r;\n" + " int a;\n" + " int aa = 0;\n" + " int aaa = 1; // comment\n" + " foo #(bar) z;\n" + " int [x:y] zz; // comment\n" + " int zzz[a:b];\n" + "} type_t;\n"}, + {"typedef struct packed {\n" + "struct packed { bit q; logic qq; logic qqq; } a_few_qs;\n" + "struct packed {\n" + "logic [1:0] q;\n" + "} one_q;\n" + "int q;\n" + "uint qq;\n" + "} nested_qs_t;", + "typedef struct packed {\n" + " struct packed {\n" + " bit q;\n" + " logic qq;\n" + " logic qqq;\n" + " } a_few_qs;\n" + " struct packed {logic [1:0] q;} one_q;\n" + " int q;\n" + " uint qq;\n" + "} nested_qs_t;\n"}, + {"typedef struct packed {\n" + "struct packed { bit q; logic qq; logic qqq; } a_few_qs;\n" + "struct packed {\n" + "// comment\n" + "logic [1:0] q;\n" + "} one_q;\n" + "int q;\n" + "uint qq;\n" + "} nested_qs_t;", + "typedef struct packed {\n" + " struct packed {\n" + " bit q;\n" + " logic qq;\n" + " logic qqq;\n" + " } a_few_qs;\n" + " struct packed {\n" + " // comment\n" + " logic [1:0] q;\n" + " } one_q;\n" + " int q;\n" + " uint qq;\n" + "} nested_qs_t;\n"}, + {"typedef struct {bit [3:0] first;\n" + "`ifdef MACRO\n" + "bit [31:0] second; generic_type_name_t third;\n" + "`endif\n" + "} type_t;\n", + "typedef struct {\n" + " bit [3:0] first;\n" + "`ifdef MACRO\n" + " bit [31:0] second;\n" + " generic_type_name_t third;\n" + "`endif\n" + "} type_t;\n"}, + {"typedef struct {\n" + "bit [3:0] first // c\n" + "; bit [31:0] second" + "// c\n" + "; generic_type_name_t third // c\n" + ";} type_t;\n", + "typedef struct {\n" + " bit [3:0] first // c\n" + ";\n" + " bit [31:0] second // c\n" + ";\n" + " generic_type_name_t third // c\n" + ";\n" + "} type_t;\n"}, + {"struct {logic test1; // c\n" + "logic test2;} test3;\n", + "struct {\n" + " logic test1; // c\n" + " logic test2;\n" + "} test3;\n"}, + {"struct {\n" + " /* t */ logic test1; /* t */\n" + "/* t */ logic test2; }test3;\n", + "struct {\n" + " /* t */ logic test1; /* t */\n" + " /* t */ logic test2;\n" + "} test3;\n"}, + // Continuation comment alignment + {"`define BAR 1 // A\n" + "module foo(); // B\n" + "wire baz; // C\n" + "endmodule:foo // D\n", + "`define BAR 1 // A\n" + "module foo (); // B\n" + " wire baz; // C\n" + "endmodule : foo // D\n"}, + {"`define BAR 1 // A\n" + "module foo(); // B\n" + " // B.1\n" + " // B.2\n" + "wire baz; // C\n" + " // C.1\n" + " // C.2\n" + "endmodule:foo // D\n" + " // D.1\n" + " // D.2\n", + "`define BAR 1 // A\n" + "module foo (); // B\n" + " // B.1\n" + " // B.2\n" + " wire baz; // C\n" + " // C.1\n" + " // C.2\n" + "endmodule : foo // D\n" + " // D.1\n" + " // D.2\n"}, + {"// W\n" + "`define BAR 1 // A\n" + " // X\n" + "module foo(); // B\n" + " // B.1\n" + " // B.2\n" + " // Y\n" + "wire baz; // C\n" + " // C.1\n" + " // C.2\n" + " // Z\n" + "endmodule:foo // D\n" + " // D.1\n" + " // D.2\n", + "// W\n" + "`define BAR 1 // A\n" + "// X\n" + "module foo (); // B\n" + " // B.1\n" + " // B.2\n" + " // Y\n" + " wire baz; // C\n" + " // C.1\n" + " // C.2\n" + " // Z\n" + "endmodule : foo // D\n" + " // D.1\n" + " // D.2\n"}, + {"module foo( // A\n" + " // A.1\n" + "// X\n" + "input wire i1 [a:b], // B\n" + " // B.1\n" + "input [c:d] i2, // C\n" + " // C.1\n" + "\n" + "// Y\n" + "output reg o1 // D\n" + " // D.1\n" + ");endmodule:foo\n", + "module foo ( // A\n" + " // A.1\n" + " // X\n" + " input wire i1[a:b], // B\n" + " // B.1\n" + " input [c:d] i2, // C\n" + " // C.1\n" + "\n" + " // Y\n" + " output reg o1 // D\n" + " // D.1\n" + ");\n" + "endmodule : foo\n"}, + // user defined type alignment + { + "module foo();\n" + " logic [5:0][5:0] net_c;\n" + " messy_type_name [1:0] net_e;\n" + "endmodule\n", + "module foo ();\n" + " logic [5:0][5:0] net_c;\n" + " messy_type_name [1:0] net_e;\n" + "endmodule\n", + }, + // Continuation comment's original starting column is allowed to differ from + // starting comment's original starting column at most by 1. + // Starting column of comments B and C will change after formatting. + // TODO: refine the column alignment depending on current vs previous line. + // https://github.com/chipsalliance/verible/pull/858#discussion_r672844015 + {"module foo (); // A\n" // Starting comment; already on correct column + " // A.1\n" // A's column + 1 + " // A.2\n" // A's column - 1 + "wire baz; // B\n" // Starting comment; will be moved left + " // B.1\n" // B's column - 1 + " // B.2\n" // B's column + 1 + " // B.3\n" // B's column + "endmodule:foo // C\n" // Starting comment; will be moved right + " // C.1\n" // C's column + 1 + " // C.2\n", // C's column - 1 + "module foo (); // A\n" + " // A.1\n" + " // A.2\n" + " wire baz; // B\n" + " // B.1\n" + " // B.2\n" + " // B.3\n" + "endmodule : foo // C\n" + " // C.1\n" + " // C.2\n"}, + {"module foo\n" + "#(\n" + " parameter type baz_t = struct packed { `BAZ(); }\n" + ")\n" + "();\n" + "endmodule\n", + "module foo #(\n" + " parameter type\n" + " baz_t = struct packed {\n" + " `BAZ();\n" + " }\n" + ") ();\n" + "endmodule\n"}, + // The same as the previous test case, but without a semicolon at the macro + // call + {"module foo\n" + "#(\n" + " parameter type baz_t = struct packed { `BAZ() }\n" + ")\n" + "();\n" + "endmodule\n", + "module foo #(\n" + " parameter type\n" + " baz_t = struct packed {\n" + " `BAZ()\n" + " }\n" + ") ();\n" + "endmodule\n"}, + // Check that comments with too large starting column difference are not + // aligned as continuation comments. + // Check that starting comments are not linked with a comment in + // comment-only line above them, even when the starting column is the same. + // All comments in this test case are aligned independently, i.e. none are + // "continuation comments". + {" // comment1\n" // A's column, but is above it + "module foo (); // A\n" + " // comment2\n" // A's column + 2 + " // comment3\n" // A's column - 2 + "wire baz; // B\n" + " // comment4\n" // B's column - 2 + " // comment5\n" // B's column + 2 + " // comment6\n" // B's column, but not directly under B + "endmodule:foo // C\n" + " // comment7\n" // C's column + 2 + " // comment8\n", // C's column, but not directly under B + "// comment1\n" + "module foo (); // A\n" + " // comment2\n" + " // comment3\n" + " wire baz; // B\n" + " // comment4\n" + " // comment5\n" + " // comment6\n" + "endmodule : foo // C\n" + "// comment7\n" + "// comment8\n"}, + // Continuation comment alignment when a line with the starting comment is + // wrapped. + {"module foo(output logic very_very_very_very_long_name // A\n" + " // A.1\n" + "); endmodule\n", + "module foo (\n" + " output logic\n" + " very_very_very_very_long_name // A\n" + " // A.1\n" + ");\n" + "endmodule\n"}, + + // Attachment of ',' to elements in enum list (with and without comments) + {"typedef enum {\n" + " first , // c1\n" + " second\n" + "} e;\n", + "typedef enum {\n" + " first, // c1\n" + " second\n" + "} e;\n"}, + {"typedef enum {\n" + " first ,\n" + " // c1\n" + " second\n" + "} e;\n", + "typedef enum {\n" + " first,\n" + " // c1\n" + " second\n" + "} e;\n"}, + {"typedef enum {\n" + " first // c1\n" + " , second\n" + "} e;\n", + "typedef enum {\n" + " first // c1\n" + " , second\n" + "} e;\n"}, + {"typedef enum {\n" + " first\n" + " // c1\n" + " , second\n" + "} e;\n", + "typedef enum {\n" + " first\n" + " // c1\n" + " , second\n" + "} e;\n"}, + {"typedef enum {\n" + " first // c1\n" + " , // c2\n" + " second\n" + "} e;\n", + "typedef enum {\n" + " first // c1\n" + " , // c2\n" + " second\n" + "} e;\n"}, + {"typedef enum {\n" + " first\n" + " // c1\n" + " ,\n" + " // c2\n" + " second\n" + "} e;\n", + "typedef enum {\n" + " first\n" + " // c1\n" + " , // c2\n" + " second\n" + "} e;\n"}, + {"typedef enum {\n" + " first\n" + " // c1\n" + " , // c2\n" + " // c3\n" + " second\n" + "} e;\n", + "typedef enum {\n" + " first\n" + " // c1\n" + " , // c2\n" + " // c3\n" + " second\n" + "} e;\n"}, + {"typedef enum {\n" + " // c1\n" + " first\n" + " // c2\n" + " , // c3\n" + " // c4\n" + " second\n" + " // c5\n" + "} e;\n", + "typedef enum {\n" + " // c1\n" + " first\n" + " // c2\n" + " , // c3\n" + " // c4\n" + " second\n" + " // c5\n" + "} e;\n"}, + {"typedef enum {\n" + " // c1\n" + " // c1+\n" + " first // c2\n" + " // c2+\n" + " , // c3\n" + " // c3+\n" + " // c4\n" + " // c4+\n" + " second // c5\n" + " // c5+\n" + "} e;\n", + "typedef enum {\n" + " // c1\n" + " // c1+\n" + " first // c2\n" + " // c2+\n" + " , // c3\n" + " // c3+\n" + " // c4\n" + " // c4+\n" + " second // c5\n" + " // c5+\n" + "} e;\n"}, + {"typedef enum {\n" + " first , /* c1 */\n" + " second\n" + "} e;\n", + "typedef enum {\n" + " first, /* c1 */\n" + " second\n" + "} e;\n"}, + {"typedef enum {\n" + " first ,\n" + " /* c1 */\n" + " second\n" + "} e;\n", + "typedef enum {\n" + " first,\n" + " /* c1 */\n" + " second\n" + "} e;\n"}, + {"typedef enum {\n" + " first /* c1 */\n" + " , second\n" + "} e;\n", + "typedef enum {\n" + " first /* c1 */\n" + " , second\n" + "} e;\n"}, + {"typedef enum {\n" + " first\n" + " /* c1 */\n" + " , second\n" + "} e;\n", + "typedef enum {\n" + " first\n" + " /* c1 */\n" + " , second\n" + "} e;\n"}, + {"typedef enum {\n" + " first /* c1 */\n" + " , /* c2 */\n" + " second\n" + "} e;\n", + "typedef enum {\n" + " first /* c1 */\n" + " , /* c2 */\n" + " second\n" + "} e;\n"}, + {"typedef enum {\n" + " first\n" + " /* c1 */\n" + " ,\n" + " /* c2 */\n" + " second\n" + "} e;\n", + "typedef enum {\n" + " first\n" + " /* c1 */\n" + " ,\n" + " /* c2 */\n" + " second\n" + "} e;\n"}, + {"typedef enum {\n" + " /* c1 */\n" + " first\n" + " /* c2 */\n" + " , /* c3 */\n" + " /* c4 */\n" + " second\n" + " /* c5 */\n" + "} e;\n", + "typedef enum {\n" + " /* c1 */\n" + " first\n" + " /* c2 */\n" + " , /* c3 */\n" + " /* c4 */\n" + " second\n" + " /* c5 */\n" + "} e;\n"}, + {"typedef enum {\n" + " /* c1 */\n" + " /* c1+ */\n" + " first /* c2 */\n" + " /* c2+ */\n" + " , /* c3 */\n" + " /* c3+ */\n" + " /* c4 */\n" + " /* c4+ */\n" + " second /* c5 */\n" + " /* c5+ */\n" + "} e;\n", + "typedef enum {\n" + " /* c1 */\n" + " /* c1+ */\n" + " first /* c2 */\n" + " /* c2+ */\n" + " , /* c3 */\n" + " /* c3+ */\n" + " /* c4 */\n" + " /* c4+ */\n" + " second /* c5 */\n" + " /* c5+ */\n" + "} e;\n"}, + {"module m;\n" + "typedef enum {\n" + " first,\n" + " second\n" + "} // c\n" + "e;\n" + "endmodule\n", + "module m;\n" + " typedef enum {\n" + " first,\n" + " second\n" + " } // c\n" + " e;\n" + "endmodule\n"}, + // Attachment of ';' preceded by EOL comment + {"module m;\n" + "typedef enum {\n" + " first,\n" + " second\n" + "} e // c\n" + ";\n" + "endmodule\n", + "module m;\n" + " typedef enum {\n" + " first,\n" + " second\n" + " } e // c\n" + " ;\n" + "endmodule\n"}, + {"module m;\n" + "typedef enum {\n" + " first,\n" + " second\n" + "} // c1\n" + "e // c2\n" + ";\n" + "endmodule\n", + "module m;\n" + " typedef enum {\n" + " first,\n" + " second\n" + " } // c1\n" + " e // c2\n" + " ;\n" + "endmodule\n"}, + {"assign foo = bar\n" + "// comment\n" + ";\n", + "assign foo = bar\n" + " // comment\n" + " ;\n"}, + {"assign foo = bar // comment\n" + ";\n", + "assign foo = bar // comment\n" + ";\n"}, + + // Attachment of ',' to elements in PortActualList (with and without + // comments) + {"module foo;\n" + " bar foobar(\n" + " .first(1) // c1\n" + " ,\n" + " .second(2) // c2\n" + " );\n" + "endmodule\n", + "module foo;\n" + " bar foobar (\n" + " .first (1) // c1\n" + " , .second(2) // c2\n" + " );\n" + "endmodule\n"}, + {"module foo;\n" + " bar foobar(\n" + " .first(1) // c1\n" + " , .second(2) // c2\n" + " );\n" + "endmodule\n", + "module foo;\n" + " bar foobar (\n" + " .first (1) // c1\n" + " , .second(2) // c2\n" + " );\n" + "endmodule\n"}, + {"module foo;\n" + " bar foobar(\n" + " .first(1)\n" + " // c1\n" + " ,\n" + " .second(2)\n" + " // c2\n" + " );\n" + "endmodule\n", + "module foo;\n" + " bar foobar (\n" + " .first (1)\n" + " // c1\n" + " , .second(2)\n" + " // c2\n" + " );\n" + "endmodule\n"}, + {"module foo;\n" + " bar foobar(\n" + " .first(1)\n" + " // c1\n" + " , .second(2)\n" + " // c2\n" + " );\n" + "endmodule\n", + "module foo;\n" + " bar foobar (\n" + " .first (1)\n" + " // c1\n" + " , .second(2)\n" + " // c2\n" + " );\n" + "endmodule\n"}, + {"module foo;\n" + " bar foobar(\n" + " .first(1)\n" + " // c1\n" + " , // c2\n" + " .second(2)\n" + " // c3\n" + " );\n" + "endmodule\n", + "module foo;\n" + " bar foobar (\n" + " .first (1)\n" + " // c1\n" + " , // c2\n" + " .second(2)\n" + " // c3\n" + " );\n" + "endmodule\n"}, + {"module foo;\n" + " bar foobar(\n" + " // c1\n" + " // c1+\n" + " .first(1) // c2\n" + " // c2+\n" + " , // c3\n" + " // c3+\n" + " .second(2) // c4\n" + " // c4+\n" + " // c5\n" + " // c5+\n" + " );\n" + "endmodule\n", + "module foo;\n" + " bar foobar (\n" + " // c1\n" + " // c1+\n" + " .first (1) // c2\n" + " // c2+\n" + " , // c3\n" + " // c3+\n" + " .second(2) // c4\n" + " // c4+\n" + " // c5\n" + " // c5+\n" + " );\n" + "endmodule\n"}, + {"module foo;\n" + " bar foobar(\n" + " .first(1) /* c1 */\n" + " ,\n" + " .second(2) /* c2 */\n" + " );\n" + "endmodule\n", + "module foo;\n" + " bar foobar (\n" + " .first (1) /* c1 */\n" + " , .second(2) /* c2 */\n" + " );\n" + "endmodule\n"}, + {"module foo;\n" + " bar foobar(\n" + " /* c1 */ .first(1),\n" + " /* c2 */ .second(2)\n" + " );\n" + "endmodule\n", + "module foo;\n" + " bar foobar (\n" + " /* c1 */.first (1),\n" + " /* c2 */.second(2)\n" + " );\n" + "endmodule\n"}, + {"module foo;\n" + " bar foobar(\n" + " .first(1) /* c1 */\n" + " , .second(2) /* c2 */\n" + " );\n" + "endmodule\n", + "module foo;\n" + " bar foobar (\n" + " .first (1) /* c1 */\n" + " , .second(2) /* c2 */\n" + " );\n" + "endmodule\n"}, + {"module foo;\n" + " bar foobar(\n" + " /* c1 */.first(1)\n" + " /* c2 */, .second(2)\n" + " );\n" + "endmodule\n", + "module foo;\n" + " bar foobar (\n" + " /* c1 */ .first (1)\n" + " /* c2 */, .second(2)\n" + " );\n" + "endmodule\n"}, + {"module foo;\n" + " bar foobar(\n" + " .first(1)\n" + " /* c1 */\n" + " ,\n" + " .second(2)\n" + " /* c2 */\n" + " );\n" + "endmodule\n", + "module foo;\n" + " bar foobar (\n" + " .first (1)\n" + " /* c1 */\n" + " , .second(2)\n" + " /* c2 */\n" + " );\n" + "endmodule\n"}, + {"module foo;\n" + " bar foobar(\n" + " .first(1)\n" + " /* c1 */\n" + " , .second(2)\n" + " /* c2 */\n" + " );\n" + "endmodule\n", + "module foo;\n" + " bar foobar (\n" + " .first (1)\n" + " /* c1 */\n" + " , .second(2)\n" + " /* c2 */\n" + " );\n" + "endmodule\n"}, + {"module foo;\n" + " bar foobar(\n" + " .first(1)\n" + " /* c1 */\n" + " , /* c2 */\n" + " .second(2)\n" + " /* c3 */\n" + " );\n" + "endmodule\n", + "module foo;\n" + " bar foobar (\n" + " .first (1)\n" + " /* c1 */\n" + " , /* c2 */\n" + " .second(2)\n" + " /* c3 */\n" + " );\n" + "endmodule\n"}, + {"module foo;\n" + " bar foobar(\n" + " .first(1)\n" + " /* c1 */\n" + " , /* c2 */\n" + " .second(2)\n" + " /* c3 */\n" + " );\n" + "endmodule\n", + "module foo;\n" + " bar foobar (\n" + " .first (1)\n" + " /* c1 */\n" + " , /* c2 */\n" + " .second(2)\n" + " /* c3 */\n" + " );\n" + "endmodule\n"}, + {"module foo;\n" + " bar foobar(\n" + " /* c1 */\n" + " /* c1+ */\n" + " .first(1) /* c2 */\n" + " /* c2+ */\n" + " , /* c3 */\n" + " /* c3+ */\n" + " .second(2) /* c4 */\n" + " /* c4+ */\n" + " /* c5 */\n" + " /* c5+ */\n" + " );\n" + "endmodule\n", + "module foo;\n" + " bar foobar (\n" + " /* c1 */\n" + " /* c1+ */\n" + " .first (1) /* c2 */\n" + " /* c2+ */\n" + " , /* c3 */\n" + " /* c3+ */\n" + " .second(2) /* c4 */\n" + " /* c4+ */\n" + " /* c5 */\n" + " /* c5+ */\n" + " );\n" + "endmodule\n"}, + + // Attachment of ',' to elements in ActualNamedParameterList (with and + // without comments) + {"module foo;\n" + " bar#(\n" + " .first(1) // c1\n" + " ,\n" + " .second(2) // c2\n" + " ) baz ();\n" + "endmodule\n", + "module foo;\n" + " bar #(\n" + " .first (1) // c1\n" + " , .second(2) // c2\n" + " ) baz ();\n" + "endmodule\n"}, + {"module foo;\n" + " bar#(\n" + " .first(1) // c1\n" + " , .second(2) // c2\n" + " ) baz ();\n" + "endmodule\n", + "module foo;\n" + " bar #(\n" + " .first (1) // c1\n" + " , .second(2) // c2\n" + " ) baz ();\n" + "endmodule\n"}, + {"module foo;\n" + " bar#(\n" + " .first(1)\n" + " // c1\n" + " ,\n" + " .second(2)\n" + " // c2\n" + " ) baz ();\n" + "endmodule\n", + "module foo;\n" + " bar #(\n" + " .first (1)\n" + " // c1\n" + " , .second(2)\n" + " // c2\n" + " ) baz ();\n" + "endmodule\n"}, + {"module foo;\n" + " bar#(\n" + " .first(1)\n" + " // c1\n" + " , .second(2)\n" + " // c2\n" + " ) baz ();\n" + "endmodule\n", + "module foo;\n" + " bar #(\n" + " .first (1)\n" + " // c1\n" + " , .second(2)\n" + " // c2\n" + " ) baz ();\n" + "endmodule\n"}, + {"module foo;\n" + " bar#(\n" + " .first(1)\n" + " // c1\n" + " , // c2\n" + " .second(2)\n" + " // c3\n" + " ) baz ();\n" + "endmodule\n", + "module foo;\n" + " bar #(\n" + " .first (1)\n" + " // c1\n" + " , // c2\n" + " .second(2)\n" + " // c3\n" + " ) baz ();\n" + "endmodule\n"}, + {"module foo;\n" + " bar#(\n" + " // c1\n" + " // c1+\n" + " .first(1) // c2\n" + " // c2+\n" + " , // c3\n" + " // c3+\n" + " .second(2) // c4\n" + " // c4+\n" + " // c5\n" + " // c5+\n" + " ) baz ();\n" + "endmodule\n", + "module foo;\n" + " bar #(\n" + " // c1\n" + " // c1+\n" + " .first (1) // c2\n" + " // c2+\n" + " , // c3\n" + " // c3+\n" + " .second(2) // c4\n" + " // c4+\n" + " // c5\n" + " // c5+\n" + " ) baz ();\n" + "endmodule\n"}, + {"module foo;\n" + " bar#(\n" + " .first(1) /* c1 */\n" + " ,\n" + " .second(2) /* c2 */\n" + " ) baz ();\n" + "endmodule\n", + "module foo;\n" + " bar #(\n" + " .first (1) /* c1 */\n" + " , .second(2) /* c2 */\n" + " ) baz ();\n" + "endmodule\n"}, + {"module foo;\n" + " bar#(\n" + " /* c1 */ .first(1),\n" + " /* c2 */ .second(2)\n" + " ) baz ();\n" + "endmodule\n", + "module foo;\n" + " bar #(\n" + " /* c1 */.first (1),\n" + " /* c2 */.second(2)\n" + " ) baz ();\n" + "endmodule\n"}, + {"module foo;\n" + " bar#(\n" + " .first(1) /* c1 */\n" + " , .second(2) /* c2 */\n" + " ) baz ();\n" + "endmodule\n", + "module foo;\n" + " bar #(\n" + " .first (1) /* c1 */\n" + " , .second(2) /* c2 */\n" + " ) baz ();\n" + "endmodule\n"}, + {"module foo;\n" + " bar#(\n" + " /* c1 */.first(1)\n" + " /* c2 */, .second(2)\n" + " ) baz ();\n" + "endmodule\n", + "module foo;\n" + " bar #(\n" + " /* c1 */ .first (1)\n" + " /* c2 */, .second(2)\n" + " ) baz ();\n" + "endmodule\n"}, + {"module foo;\n" + " bar#(\n" + " .first(1)\n" + " /* c1 */\n" + " ,\n" + " .second(2)\n" + " /* c2 */\n" + " ) baz ();\n" + "endmodule\n", + "module foo;\n" + " bar #(\n" + " .first (1)\n" + " /* c1 */\n" + " , .second(2)\n" + " /* c2 */\n" + " ) baz ();\n" + "endmodule\n"}, + {"module foo;\n" + " bar#(\n" + " .first(1)\n" + " /* c1 */\n" + " , .second(2)\n" + " /* c2 */\n" + " ) baz ();\n" + "endmodule\n", + "module foo;\n" + " bar #(\n" + " .first (1)\n" + " /* c1 */\n" + " , .second(2)\n" + " /* c2 */\n" + " ) baz ();\n" + "endmodule\n"}, + {"module foo;\n" + " bar#(\n" + " .first(1)\n" + " /* c1 */\n" + " , /* c2 */\n" + " .second(2)\n" + " /* c3 */\n" + " ) baz ();\n" + "endmodule\n", + "module foo;\n" + " bar #(\n" + " .first (1)\n" + " /* c1 */\n" + " , /* c2 */\n" + " .second(2)\n" + " /* c3 */\n" + " ) baz ();\n" + "endmodule\n"}, + {"module foo;\n" + " bar#(\n" + " .first(1)\n" + " /* c1 */\n" + " , /* c2 */\n" + " .second(2)\n" + " /* c3 */\n" + " ) baz ();\n" + "endmodule\n", + "module foo;\n" + " bar #(\n" + " .first (1)\n" + " /* c1 */\n" + " , /* c2 */\n" + " .second(2)\n" + " /* c3 */\n" + " ) baz ();\n" + "endmodule\n"}, + {"module foo;\n" + " bar#(\n" + " /* c1 */\n" + " /* c1+ */\n" + " .first(1) /* c2 */\n" + " /* c2+ */\n" + " , /* c3 */\n" + " /* c3+ */\n" + " .second(2) /* c4 */\n" + " /* c4+ */\n" + " /* c5 */\n" + " /* c5+ */\n" + " ) baz ();\n" + "endmodule\n", + "module foo;\n" + " bar #(\n" + " /* c1 */\n" + " /* c1+ */\n" + " .first (1) /* c2 */\n" + " /* c2+ */\n" + " , /* c3 */\n" + " /* c3+ */\n" + " .second(2) /* c4 */\n" + " /* c4+ */\n" + " /* c5 */\n" + " /* c5+ */\n" + " ) baz ();\n" + "endmodule\n"}, + + // ":" and "'{" in a single line + {"assign foo[2] =\n" + "'{\n" + "bar: 1'b1, // c\n" + "baz: 1'b0, // c\n" + "foobar: CONSTANT,\n" + "qux:\n" + "{\n" + "a, // c\n" + "b\n" + "}\n" + "};\n", + "assign foo[2] = '{\n" + " bar: 1'b1, // c\n" + " baz: 1'b0, // c\n" + " foobar: CONSTANT,\n" + " qux: {\n" + " a, // c\n" + " b\n" + " }\n" + " };\n"}, + {"assign a = (b) ? '{c: d[e], f: '1} : g;\n", + "assign a = (b) ?\n" + " '{c: d[e], f: '1}\n" + " : g;\n"}, + + // ----------------------------------------------------------------- + // Comments around `else`. + // Check whether `else` partition is found correctly and that actual code is + // not appended to EOL comments. + + // generate if + + {"module zx;\n" + "if (x) assign z=y;\n" + "// eol-c\n" + "else if (r) assign z=w;\n" + "else assign x=y;\n" + "endmodule\n", + "module zx;\n" + " if (x) assign z = y;\n" + " // eol-c\n" + " else if (r) assign z = w;\n" + " else assign x = y;\n" + "endmodule\n"}, + {"module zx;\n" + "if (x) assign z=y;\n" + "// eol-c\n" + "// eol-c\n" + "else if (r) assign z=w;\n" + "else assign x=y;\n" + "endmodule\n", + "module zx;\n" + " if (x) assign z = y;\n" + " // eol-c\n" + " // eol-c\n" + " else if (r) assign z = w;\n" + " else assign x = y;\n" + "endmodule\n"}, + {"module zx;\n" + "if (x) assign z=y;\n" + "else // eol-c\n" + "if (r) assign z=w;\n" + "else assign x=y;\n" + "endmodule\n", + "module zx;\n" + " if (x) assign z = y;\n" + " else // eol-c\n" + " if (r) assign z = w;\n" + " else assign x = y;\n" + "endmodule\n"}, + {"module zx;\n" + "if (x) assign z=y;\n" + "else\n" + "// eol-c\n" + "if (r) assign z=w;\n" + "else assign x=y;\n" + "endmodule\n", + "module zx;\n" + " if (x) assign z = y;\n" + " else\n" + " // eol-c\n" + " if (r)\n" + " assign z = w;\n" + " else assign x = y;\n" + "endmodule\n"}, + {"module zx;\n" + "if (x) assign z=y;\n" + "// eol-c\n" + "else // eol-c\n" + "if (r) assign z=w;\n" + "else assign x=y;\n" + "endmodule\n", + "module zx;\n" + " if (x) assign z = y;\n" + " // eol-c\n" + " else // eol-c\n" + " if (r) assign z = w;\n" + " else assign x = y;\n" + "endmodule\n"}, + {"module zx;\n" + "if (x) assign z=y;\n" + "else // eol-c\n" + "// eol-c\n" + "if (r) assign z=w;\n" + "else assign x=y;\n" + "endmodule\n", + "module zx;\n" + " if (x) assign z = y;\n" + " else // eol-c\n" + " // eol-c\n" + " if (r)\n" + " assign z = w;\n" + " else assign x = y;\n" + "endmodule\n"}, + {"module zx;\n" + "if (x) assign z=y;\n" + "// eol-c\n" + "else // eol-c\n" + "// eol-c\n" + "if (r) assign z=w;\n" + "else assign x=y;\n" + "endmodule\n", + "module zx;\n" + " if (x) assign z = y;\n" + " // eol-c\n" + " else // eol-c\n" + " // eol-c\n" + " if (r)\n" + " assign z = w;\n" + " else assign x = y;\n" + "endmodule\n"}, + {"module zx;\n" + "if (x) assign z=y;\n" + "// eol-c\n" + "else // eol-c\n" + "// eol-c\n" + "if\n" + "// eol-c\n" + "(r) assign z=w;\n" + "else assign x=y;\n" + "endmodule\n", + "module zx;\n" + " if (x) assign z = y;\n" + " // eol-c\n" + " else // eol-c\n" + " // eol-c\n" + " if\n" + " // eol-c\n" + " (r)\n" + " assign z = w;\n" + " else assign x = y;\n" + "endmodule\n"}, + {"module zx;\n" + "if (x) assign z=y;\n" + "// eol-c\n" + "// eol-c\n" + "else // eol-c\n" + "// eol-c\n" + "// eol-c\n" + "if\n" + "// eol-c\n" + "// eol-c\n" + "(r) assign z=w;\n" + "else assign x=y;\n" + "endmodule\n", + "module zx;\n" + " if (x) assign z = y;\n" + " // eol-c\n" + " // eol-c\n" + " else // eol-c\n" + " // eol-c\n" + " // eol-c\n" + " if\n" + " // eol-c\n" + " // eol-c\n" + " (r)\n" + " assign z = w;\n" + " else assign x = y;\n" + "endmodule\n"}, + + // generate if with function call + + {"module zx;\n" + "if (x) assign z=y;\n" + "// eol-c\n" + "else if (foo(x) == bar(1, 2)) assign z=w;\n" + "else assign x=y;\n" + "endmodule\n", + "module zx;\n" + " if (x) assign z = y;\n" + " // eol-c\n" + " else if (foo(x) == bar(1, 2))\n" + " assign z = w;\n" + " else assign x = y;\n" + "endmodule\n"}, + {"module zx;\n" + "if (x) assign z=y;\n" + "// eol-c\n" + "// eol-c\n" + "else if (foo(x) == bar(1, 2)) assign z=w;\n" + "else assign x=y;\n" + "endmodule\n", + "module zx;\n" + " if (x) assign z = y;\n" + " // eol-c\n" + " // eol-c\n" + " else if (foo(x) == bar(1, 2))\n" + " assign z = w;\n" + " else assign x = y;\n" + "endmodule\n"}, + {"module zx;\n" + "if (x) assign z=y;\n" + "else // eol-c\n" + "if (foo(x) == bar(1, 2)) assign z=w;\n" + "else assign x=y;\n" + "endmodule\n", + "module zx;\n" + " if (x) assign z = y;\n" + " else // eol-c\n" + " if (foo(x) == bar(1, 2)) assign z = w;\n" + " else assign x = y;\n" + "endmodule\n"}, + {"module zx;\n" + "if (x) assign z=y;\n" + "else\n" + "// eol-c\n" + "if (foo(x) == bar(1, 2)) assign z=w;\n" + "else assign x=y;\n" + "endmodule\n", + "module zx;\n" + " if (x) assign z = y;\n" + " else\n" + " // eol-c\n" + " if (foo(\n" + " x\n" + " ) == bar(\n" + " 1, 2\n" + " ))\n" + " assign z = w;\n" + " else assign x = y;\n" + "endmodule\n"}, + {"module zx;\n" + "if (x) assign z=y;\n" + "// eol-c\n" + "else // eol-c\n" + "if (foo(x) == bar(1, 2)) assign z=w;\n" + "else assign x=y;\n" + "endmodule\n", + "module zx;\n" + " if (x) assign z = y;\n" + " // eol-c\n" + " else // eol-c\n" + " if (foo(x) == bar(1, 2)) assign z = w;\n" + " else assign x = y;\n" + "endmodule\n"}, + {"module zx;\n" + "if (x) assign z=y;\n" + "else // eol-c\n" + "// eol-c\n" + "if (foo(x) == bar(1, 2)) assign z=w;\n" + "else assign x=y;\n" + "endmodule\n", + "module zx;\n" + " if (x) assign z = y;\n" + " else // eol-c\n" + " // eol-c\n" + " if (foo(\n" + " x\n" + " ) == bar(\n" + " 1, 2\n" + " ))\n" + " assign z = w;\n" + " else assign x = y;\n" + "endmodule\n"}, + {"module zx;\n" + "if (x) assign z=y;\n" + "// eol-c\n" + "else // eol-c\n" + "// eol-c\n" + "if (foo(x) == bar(1, 2)) assign z=w;\n" + "else assign x=y;\n" + "endmodule\n", + "module zx;\n" + " if (x) assign z = y;\n" + " // eol-c\n" + " else // eol-c\n" + " // eol-c\n" + " if (foo(\n" + " x\n" + " ) == bar(\n" + " 1, 2\n" + " ))\n" + " assign z = w;\n" + " else assign x = y;\n" + "endmodule\n"}, + {"module zx;\n" + "if (x) assign z=y;\n" + "// eol-c\n" + "else // eol-c\n" + "// eol-c\n" + "if\n" + "// eol-c\n" + "(foo(x) == bar(1, 2)) assign z=w;\n" + "else assign x=y;\n" + "endmodule\n", + "module zx;\n" + " if (x) assign z = y;\n" + " // eol-c\n" + " else // eol-c\n" + " // eol-c\n" + " if\n" + " // eol-c\n" + " (foo(\n" + " x\n" + " ) == bar(\n" + " 1, 2\n" + " ))\n" + " assign z = w;\n" + " else assign x = y;\n" + "endmodule\n"}, + {"module zx;\n" + "if (x) assign z=y;\n" + "// eol-c\n" + "// eol-c\n" + "else // eol-c\n" + "// eol-c\n" + "// eol-c\n" + "if\n" + "// eol-c\n" + "// eol-c\n" + "(foo(x) == bar(1, 2)) assign z=w;\n" + "else assign x=y;\n" + "endmodule\n", + "module zx;\n" + " if (x) assign z = y;\n" + " // eol-c\n" + " // eol-c\n" + " else // eol-c\n" + " // eol-c\n" + " // eol-c\n" + " if\n" + " // eol-c\n" + " // eol-c\n" + " (foo(\n" + " x\n" + " ) == bar(\n" + " 1, 2\n" + " ))\n" + " assign z = w;\n" + " else assign x = y;\n" + "endmodule\n"}, + + // else begin + + {"module zx;\n" + "always begin\n" + "if (a) b<=1;\n" + "// eol-c\n" + "else begin b<=2;\n" + "end\n" + "end\n" + "endmodule\n", + "module zx;\n" + " always begin\n" + " if (a) b <= 1;\n" + " // eol-c\n" + " else begin\n" + " b <= 2;\n" + " end\n" + " end\n" + "endmodule\n"}, + {"module zx;\n" + "always begin\n" + "if (a) b<=1;\n" + "// eol-c\n" + "// eol-c\n" + "else begin b<=2;\n" + "end\n" + "end\n" + "endmodule\n", + "module zx;\n" + " always begin\n" + " if (a) b <= 1;\n" + " // eol-c\n" + " // eol-c\n" + " else begin\n" + " b <= 2;\n" + " end\n" + " end\n" + "endmodule\n"}, + {"module zx;\n" + "always begin\n" + "if (a) b<=1;\n" + "else // eol-c\n" + "begin b<=2;\n" + "end\n" + "end\n" + "endmodule\n", + "module zx;\n" + " always begin\n" + " if (a) b <= 1;\n" + " else // eol-c\n" + " begin\n" + " b <= 2;\n" + " end\n" + " end\n" + "endmodule\n"}, + {"module zx;\n" + "always begin\n" + "if (a) b<=1;\n" + "else\n" + "// eol-c\n" + "begin b<=2;\n" + "end\n" + "end\n" + "endmodule\n", + "module zx;\n" + " always begin\n" + " if (a) b <= 1;\n" + " else\n" + " // eol-c\n" + " begin\n" + " b <= 2;\n" + " end\n" + " end\n" + "endmodule\n"}, + {"module zx;\n" + "always begin\n" + "if (a) b<=1;\n" + "// eol-c\n" + "else // eol-c\n" + "begin b<=2;\n" + "end\n" + "end\n" + "endmodule\n", + "module zx;\n" + " always begin\n" + " if (a) b <= 1;\n" + " // eol-c\n" + " else // eol-c\n" + " begin\n" + " b <= 2;\n" + " end\n" + " end\n" + "endmodule\n"}, + {"module zx;\n" + "always begin\n" + "if (a) b<=1;\n" + "else // eol-c\n" + "// eol-c\n" + "begin b<=2;\n" + "end\n" + "end\n" + "endmodule\n", + "module zx;\n" + " always begin\n" + " if (a) b <= 1;\n" + " else // eol-c\n" + " // eol-c\n" + " begin\n" + " b <= 2;\n" + " end\n" + " end\n" + "endmodule\n"}, + + // else if + + {"module zx;\n" + "always @(clr or set)\n" + "if (clr) assign q=0;\n" + "// eol-c\n" + "else if (set) assign q=1;\n" + "else deassign q;\n" + "endmodule\n", + "module zx;\n" + " always @(clr or set)\n" + " if (clr) assign q = 0;\n" + " // eol-c\n" + " else if (set) assign q = 1;\n" + " else deassign q;\n" + "endmodule\n"}, + {"module zx;\n" + "always @(clr or set)\n" + "if (clr) assign q=0;\n" + "// eol-c\n" + "// eol-c\n" + "else if (set) assign q=1;\n" + "else deassign q;\n" + "endmodule\n", + "module zx;\n" + " always @(clr or set)\n" + " if (clr) assign q = 0;\n" + " // eol-c\n" + " // eol-c\n" + " else if (set) assign q = 1;\n" + " else deassign q;\n" + "endmodule\n"}, + {"module zx;\n" + "always @(clr or set)\n" + "if (clr) assign q=0;\n" + "else // eol-c\n" + "if (set) assign q=1;\n" + "else deassign q;\n" + "endmodule\n", + "module zx;\n" + " always @(clr or set)\n" + " if (clr) assign q = 0;\n" + " else // eol-c\n" + " if (set) assign q = 1;\n" + " else deassign q;\n" + "endmodule\n"}, + {"module zx;\n" + "always @(clr or set)\n" + "if (clr) assign q=0;\n" + "else\n" + "// eol-c\n" + "if (set) assign q=1;\n" + "else deassign q;\n" + "endmodule\n", + "module zx;\n" + " always @(clr or set)\n" + " if (clr) assign q = 0;\n" + " else\n" + " // eol-c\n" + " if (set)\n" + " assign q = 1;\n" + " else deassign q;\n" + "endmodule\n"}, + {"module zx;\n" + "always @(clr or set)\n" + "if (clr) assign q=0;\n" + "// eol-c\n" + "else // eol-c\n" + "if (set) assign q=1;\n" + "else deassign q;\n" + "endmodule\n", + "module zx;\n" + " always @(clr or set)\n" + " if (clr) assign q = 0;\n" + " // eol-c\n" + " else // eol-c\n" + " if (set) assign q = 1;\n" + " else deassign q;\n" + "endmodule\n"}, + {"module zx;\n" + "always @(clr or set)\n" + "if (clr) assign q=0;\n" + "else // eol-c\n" + "// eol-c\n" + "if (set) assign q=1;\n" + "else deassign q;\n" + "endmodule\n", + "module zx;\n" + " always @(clr or set)\n" + " if (clr) assign q = 0;\n" + " else // eol-c\n" + " // eol-c\n" + " if (set)\n" + " assign q = 1;\n" + " else deassign q;\n" + "endmodule\n"}, + {"module zx;\n" + "always @(clr or set)\n" + "if (clr) assign q=0;\n" + "// eol-c\n" + "else // eol-c\n" + "// eol-c\n" + "if (set) assign q=1;\n" + "else deassign q;\n" + "endmodule\n", + "module zx;\n" + " always @(clr or set)\n" + " if (clr) assign q = 0;\n" + " // eol-c\n" + " else // eol-c\n" + " // eol-c\n" + " if (set)\n" + " assign q = 1;\n" + " else deassign q;\n" + "endmodule\n"}, + {"module zx;\n" + "always @(clr or set)\n" + "if (clr) assign q=0;\n" + "// eol-c\n" + "else // eol-c\n" + "// eol-c\n" + "if\n" + "// eol-c\n" + "(set) assign q=1;\n" + "else deassign q;\n" + "endmodule\n", + "module zx;\n" + " always @(clr or set)\n" + " if (clr) assign q = 0;\n" + " // eol-c\n" + " else // eol-c\n" + " // eol-c\n" + " if\n" + " // eol-c\n" + " (set)\n" + " assign q = 1;\n" + " else deassign q;\n" + "endmodule\n"}, + {"module zx;\n" + "always @(clr or set)\n" + "if (clr) assign q=0;\n" + "// eol-c\n" + "// eol-c\n" + "else // eol-c\n" + "// eol-c\n" + "// eol-c\n" + "if\n" + "// eol-c\n" + "// eol-c\n" + "(set) assign q=1;\n" + "else deassign q;\n" + "endmodule\n", + "module zx;\n" + " always @(clr or set)\n" + " if (clr) assign q = 0;\n" + " // eol-c\n" + " // eol-c\n" + " else // eol-c\n" + " // eol-c\n" + " // eol-c\n" + " if\n" + " // eol-c\n" + " // eol-c\n" + " (set)\n" + " assign q = 1;\n" + " else deassign q;\n" + "endmodule\n"}, + + // else if with function call + + {"module zx;\n" + "always @(clr or set)\n" + "if (clr) assign q=0;\n" + "// eol-c\n" + "else if (foo(clr, set, 1)) assign q=1;\n" + "else deassign q;\n" + "endmodule\n", + "module zx;\n" + " always @(clr or set)\n" + " if (clr) assign q = 0;\n" + " // eol-c\n" + " else if (foo(clr, set, 1))\n" + " assign q = 1;\n" + " else deassign q;\n" + "endmodule\n"}, + {"module zx;\n" + "always @(clr or set)\n" + "if (clr) assign q=0;\n" + "// eol-c\n" + "// eol-c\n" + "else if (foo(clr, set, 1)) assign q=1;\n" + "else deassign q;\n" + "endmodule\n", + "module zx;\n" + " always @(clr or set)\n" + " if (clr) assign q = 0;\n" + " // eol-c\n" + " // eol-c\n" + " else if (foo(clr, set, 1))\n" + " assign q = 1;\n" + " else deassign q;\n" + "endmodule\n"}, + {"module zx;\n" + "always @(clr or set)\n" + "if (clr) assign q=0;\n" + "else // eol-c\n" + "if (foo(clr, set, 1)) assign q=1;\n" + "else deassign q;\n" + "endmodule\n", + "module zx;\n" + " always @(clr or set)\n" + " if (clr) assign q = 0;\n" + " else // eol-c\n" + " if (foo(clr, set, 1)) assign q = 1;\n" + " else deassign q;\n" + "endmodule\n"}, + {"module zx;\n" + "always @(clr or set)\n" + "if (clr) assign q=0;\n" + "else\n" + "// eol-c\n" + "if (foo(clr, set, 1)) assign q=1;\n" + "else deassign q;\n" + "endmodule\n", + "module zx;\n" + " always @(clr or set)\n" + " if (clr) assign q = 0;\n" + " else\n" + " // eol-c\n" + " if (foo(\n" + " clr, set, 1\n" + " ))\n" + " assign q = 1;\n" + " else deassign q;\n" + "endmodule\n"}, + {"module zx;\n" + "always @(clr or set)\n" + "if (clr) assign q=0;\n" + "// eol-c\n" + "else // eol-c\n" + "if (foo(clr, set, 1)) assign q=1;\n" + "else deassign q;\n" + "endmodule\n", + "module zx;\n" + " always @(clr or set)\n" + " if (clr) assign q = 0;\n" + " // eol-c\n" + " else // eol-c\n" + " if (foo(clr, set, 1)) assign q = 1;\n" + " else deassign q;\n" + "endmodule\n"}, + {"module zx;\n" + "always @(clr or set)\n" + "if (clr) assign q=0;\n" + "else // eol-c\n" + "// eol-c\n" + "if (foo(clr, set, 1)) assign q=1;\n" + "else deassign q;\n" + "endmodule\n", + "module zx;\n" + " always @(clr or set)\n" + " if (clr) assign q = 0;\n" + " else // eol-c\n" + " // eol-c\n" + " if (foo(\n" + " clr, set, 1\n" + " ))\n" + " assign q = 1;\n" + " else deassign q;\n" + "endmodule\n"}, + {"module zx;\n" + "always @(clr or set)\n" + "if (clr) assign q=0;\n" + "// eol-c\n" + "else // eol-c\n" + "// eol-c\n" + "if (foo(clr, set, 1)) assign q=1;\n" + "else deassign q;\n" + "endmodule\n", + "module zx;\n" + " always @(clr or set)\n" + " if (clr) assign q = 0;\n" + " // eol-c\n" + " else // eol-c\n" + " // eol-c\n" + " if (foo(\n" + " clr, set, 1\n" + " ))\n" + " assign q = 1;\n" + " else deassign q;\n" + "endmodule\n"}, + {"module zx;\n" + "always @(clr or set)\n" + "if (clr) assign q=0;\n" + "// eol-c\n" + "else // eol-c\n" + "// eol-c\n" + "if\n" + "// eol-c\n" + "(foo(clr, set, 1)) assign q=1;\n" + "else deassign q;\n" + "endmodule\n", + "module zx;\n" + " always @(clr or set)\n" + " if (clr) assign q = 0;\n" + " // eol-c\n" + " else // eol-c\n" + " // eol-c\n" + " if\n" + " // eol-c\n" + " (foo(\n" + " clr, set, 1\n" + " ))\n" + " assign q = 1;\n" + " else deassign q;\n" + "endmodule\n"}, + {"module zx;\n" + "always @(clr or set)\n" + "if (clr) assign q=0;\n" + "// eol-c\n" + "// eol-c\n" + "else // eol-c\n" + "// eol-c\n" + "// eol-c\n" + "if\n" + "// eol-c\n" + "// eol-c\n" + "(foo(clr, set, 1)) assign q=1;\n" + "else deassign q;\n" + "endmodule\n", + "module zx;\n" + " always @(clr or set)\n" + " if (clr) assign q = 0;\n" + " // eol-c\n" + " // eol-c\n" + " else // eol-c\n" + " // eol-c\n" + " // eol-c\n" + " if\n" + " // eol-c\n" + " // eol-c\n" + " (foo(\n" + " clr, set, 1\n" + " ))\n" + " assign q = 1;\n" + " else deassign q;\n" + "endmodule\n"}, + + // ----------------------------------------------------------------- + // Comments around and inside macro calls. + +}; + +TEST(FormatterEndToEndTest, AlignFormatterTestCases) { + RunFormatterTestCases40(kAlignFormatterTestCases); +} + +TEST(FormatterEndToEndTest, AlignmentGroupBoundaryNone) { + // Default behavior: separator comments and blank lines do NOT break groups. + static constexpr FormatterTestCase kTestCases[] = { + {// Separator comment does not break alignment group + "module m;\n" + "assign foo = 1'b1;\n" + "assign baar = 1'b0;\n" + "// ============\n" + "assign baaaaz = 1'b1;\n" + "assign c = 1'b0;\n" + "endmodule\n", + "module m;\n" + " assign foo = 1'b1;\n" + " assign baar = 1'b0;\n" + " // ============\n" + " assign baaaaz = 1'b1;\n" + " assign c = 1'b0;\n" + "endmodule\n"}, + }; + FormatStyle style; + style.column_limit = 40; + style.indentation_spaces = 2; + style.wrap_spaces = 4; + style.alignment_group_boundary = AlignmentGroupBoundary::kNone; + style.assignment_statement_alignment = AlignmentPolicy::kAlign; + for (const auto &test_case : kTestCases) { + VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; + std::ostringstream stream; + const auto status = + FormatVerilog(test_case.input, "<filename>", style, stream); + EXPECT_OK(status) << status.message(); + EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; + } +} + +TEST(FormatterEndToEndTest, AlignmentGroupBoundarySeparatorComments) { + static constexpr FormatterTestCase kTestCases[] = { + {// Separator comment breaks alignment group + "module m;\n" + "assign foo = 1'b1;\n" + "assign baar = 1'b0;\n" + "// ============\n" + "assign baaaaz = 1'b1;\n" + "assign c = 1'b0;\n" + "endmodule\n", + "module m;\n" + " assign foo = 1'b1;\n" + " assign baar = 1'b0;\n" + " // ============\n" + " assign baaaaz = 1'b1;\n" + " assign c = 1'b0;\n" + "endmodule\n"}, + {// Dashes separator also breaks + "module m;\n" + "assign foo = 1'b1;\n" + "assign baar = 1'b0;\n" + "// ------------\n" + "assign baaaaz = 1'b1;\n" + "assign c = 1'b0;\n" + "endmodule\n", + "module m;\n" + " assign foo = 1'b1;\n" + " assign baar = 1'b0;\n" + " // ------------\n" + " assign baaaaz = 1'b1;\n" + " assign c = 1'b0;\n" + "endmodule\n"}, + {// Captioned divider (text between separator runs) also breaks + "module m;\n" + "assign foo = 1'b1;\n" + "assign baar = 1'b0;\n" + "// ------ section heading ------\n" + "assign baaaaz = 1'b1;\n" + "assign c = 1'b0;\n" + "endmodule\n", + "module m;\n" + " assign foo = 1'b1;\n" + " assign baar = 1'b0;\n" + " // ------ section heading ------\n" + " assign baaaaz = 1'b1;\n" + " assign c = 1'b0;\n" + "endmodule\n"}, + {// Leading-only divider run with trailing caption text + "module m;\n" + "assign foo = 1'b1;\n" + "assign baar = 1'b0;\n" + "// ==== Registers\n" + "assign baaaaz = 1'b1;\n" + "assign c = 1'b0;\n" + "endmodule\n", + "module m;\n" + " assign foo = 1'b1;\n" + " assign baar = 1'b0;\n" + " // ==== Registers\n" + " assign baaaaz = 1'b1;\n" + " assign c = 1'b0;\n" + "endmodule\n"}, + {// No space after // also works + "module m;\n" + "assign foo = 1'b1;\n" + "assign baar = 1'b0;\n" + "//============\n" + "assign baaaaz = 1'b1;\n" + "assign c = 1'b0;\n" + "endmodule\n", + "module m;\n" + " assign foo = 1'b1;\n" + " assign baar = 1'b0;\n" + " //============\n" + " assign baaaaz = 1'b1;\n" + " assign c = 1'b0;\n" + "endmodule\n"}, + {// Slash separator (/////) also works + "module m;\n" + "assign foo = 1'b1;\n" + "assign baar = 1'b0;\n" + "//////////\n" + "assign baaaaz = 1'b1;\n" + "assign c = 1'b0;\n" + "endmodule\n", + "module m;\n" + " assign foo = 1'b1;\n" + " assign baar = 1'b0;\n" + " //////////\n" + " assign baaaaz = 1'b1;\n" + " assign c = 1'b0;\n" + "endmodule\n"}, + {// Regular comment does NOT break alignment + "module m;\n" + "assign foo = 1'b1;\n" + "assign baar = 1'b0;\n" + "// Title text\n" + "assign baaaaz = 1'b1;\n" + "assign c = 1'b0;\n" + "endmodule\n", + "module m;\n" + " assign foo = 1'b1;\n" + " assign baar = 1'b0;\n" + " // Title text\n" + " assign baaaaz = 1'b1;\n" + " assign c = 1'b0;\n" + "endmodule\n"}, + {// Multi-line comment block with separators + "module m;\n" + "assign foo = 1'b1;\n" + "assign baar = 1'b0;\n" + "// ============\n" + "// Title\n" + "// ============\n" + "assign baaaaz = 1'b1;\n" + "assign c = 1'b0;\n" + "endmodule\n", + "module m;\n" + " assign foo = 1'b1;\n" + " assign baar = 1'b0;\n" + " // ============\n" + " // Title\n" + " // ============\n" + " assign baaaaz = 1'b1;\n" + " assign c = 1'b0;\n" + "endmodule\n"}, + {// Short repeated body (3 chars) does NOT break + "module m;\n" + "assign foo = 1'b1;\n" + "assign baar = 1'b0;\n" + "// ---\n" + "assign baaaaz = 1'b1;\n" + "assign c = 1'b0;\n" + "endmodule\n", + "module m;\n" + " assign foo = 1'b1;\n" + " assign baar = 1'b0;\n" + " // ---\n" + " assign baaaaz = 1'b1;\n" + " assign c = 1'b0;\n" + "endmodule\n"}, + {// Declarations also respect separator comments + "module m;\n" + "logic a;\n" + "logic [7:0] b;\n" + "// ============\n" + "logic c_long_name;\n" + "logic d;\n" + "endmodule\n", + "module m;\n" + " logic a;\n" + " logic [7:0] b;\n" + " // ============\n" + " logic c_long_name;\n" + " logic d;\n" + "endmodule\n"}, + {// Statements in always blocks + "module m;\n" + "always_comb begin\n" + "aaaaa = b;\n" + "c = 1'b0;\n" + "// ============\n" + "dd = eee;\n" + "ffffff = g;\n" + "end\n" + "endmodule\n", + "module m;\n" + " always_comb begin\n" + " aaaaa = b;\n" + " c = 1'b0;\n" + " // ============\n" + " dd = eee;\n" + " ffffff = g;\n" + " end\n" + "endmodule\n"}, + }; + FormatStyle style; + style.column_limit = 40; + style.indentation_spaces = 2; + style.wrap_spaces = 4; + style.alignment_group_boundary = AlignmentGroupBoundary::kSeparatorComments; + style.assignment_statement_alignment = AlignmentPolicy::kAlign; + style.module_net_variable_alignment = AlignmentPolicy::kAlign; + for (const auto &test_case : kTestCases) { + VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; + std::ostringstream stream; + const auto status = + FormatVerilog(test_case.input, "<filename>", style, stream); + EXPECT_OK(status) << status.message(); + EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; + } +} + +TEST(FormatterEndToEndTest, AlignmentGroupBoundaryBlankLines) { + static constexpr FormatterTestCase kTestCases[] = { + {// Blank line breaks alignment group + "module m;\n" + "assign foo = 1'b1;\n" + "assign baar = 1'b0;\n" + "\n" + "assign baaaaz = 1'b1;\n" + "assign c = 1'b0;\n" + "endmodule\n", + "module m;\n" + " assign foo = 1'b1;\n" + " assign baar = 1'b0;\n" + "\n" + " assign baaaaz = 1'b1;\n" + " assign c = 1'b0;\n" + "endmodule\n"}, + {// No blank line: single alignment group + "module m;\n" + "assign foo = 1'b1;\n" + "assign baar = 1'b0;\n" + "assign baaaaz = 1'b1;\n" + "assign c = 1'b0;\n" + "endmodule\n", + "module m;\n" + " assign foo = 1'b1;\n" + " assign baar = 1'b0;\n" + " assign baaaaz = 1'b1;\n" + " assign c = 1'b0;\n" + "endmodule\n"}, + {// Single item before blank line (not enough for alignment) + "module m;\n" + "assign foo = 1'b1;\n" + "\n" + "assign baaaaz = 1'b1;\n" + "assign c = 1'b0;\n" + "endmodule\n", + "module m;\n" + " assign foo = 1'b1;\n" + "\n" + " assign baaaaz = 1'b1;\n" + " assign c = 1'b0;\n" + "endmodule\n"}, + {// Separator comment does NOT break (only blank lines) + "module m;\n" + "assign foo = 1'b1;\n" + "assign baar = 1'b0;\n" + "// ============\n" + "assign baaaaz = 1'b1;\n" + "assign c = 1'b0;\n" + "endmodule\n", + "module m;\n" + " assign foo = 1'b1;\n" + " assign baar = 1'b0;\n" + " // ============\n" + " assign baaaaz = 1'b1;\n" + " assign c = 1'b0;\n" + "endmodule\n"}, + }; + FormatStyle style; + style.column_limit = 40; + style.indentation_spaces = 2; + style.wrap_spaces = 4; + style.alignment_group_boundary = AlignmentGroupBoundary::kBlankLines; + style.assignment_statement_alignment = AlignmentPolicy::kAlign; + for (const auto &test_case : kTestCases) { + VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; + std::ostringstream stream; + const auto status = + FormatVerilog(test_case.input, "<filename>", style, stream); + EXPECT_OK(status) << status.message(); + EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; + } +} + +TEST(FormatterEndToEndTest, + AlignmentGroupBoundaryBlankLinesAndSeparatorComments) { + static constexpr FormatterTestCase kTestCases[] = { + {// Both blank line and separator break groups + "module m;\n" + "assign foo = 1'b1;\n" + "assign baar = 1'b0;\n" + "\n" + "assign baaaaz = 1'b1;\n" + "assign c = 1'b0;\n" + "// ============\n" + "assign dd = 1'b1;\n" + "assign eee = 1'b0;\n" + "endmodule\n", + "module m;\n" + " assign foo = 1'b1;\n" + " assign baar = 1'b0;\n" + "\n" + " assign baaaaz = 1'b1;\n" + " assign c = 1'b0;\n" + " // ============\n" + " assign dd = 1'b1;\n" + " assign eee = 1'b0;\n" + "endmodule\n"}, + }; + FormatStyle style; + style.column_limit = 40; + style.indentation_spaces = 2; + style.wrap_spaces = 4; + style.alignment_group_boundary = + AlignmentGroupBoundary::kBlankLinesAndSeparatorComments; + style.assignment_statement_alignment = AlignmentPolicy::kAlign; + for (const auto &test_case : kTestCases) { + VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; + std::ostringstream stream; + const auto status = + FormatVerilog(test_case.input, "<filename>", style, stream); + EXPECT_OK(status) << status.message(); + EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; + } +} + +// Verify kAlign behavior for body-level param/localparam declarations +// in module and package bodies. +TEST(FormatterEndToEndTest, ParamDeclarationAlignmentBasics) { + static constexpr FormatterTestCase kTestCases[] = { + {// localparam alignment in module body + "module m;\n" + "localparam foo = 4'b0000;\n" + "localparam barr = 4'b0010;\n" + "localparam baaaaz = 4'b0111;\n" + "endmodule\n", + "module m;\n" + " localparam foo = 4'b0000;\n" + " localparam barr = 4'b0010;\n" + " localparam baaaaz = 4'b0111;\n" + "endmodule\n"}, + {// localparam alignment in package body + "package p;\n" + "localparam foo = 4'b0000;\n" + "localparam barr = 4'b0010;\n" + "localparam baaaaz = 4'b0111;\n" + "endpackage\n", + "package p;\n" + " localparam foo = 4'b0000;\n" + " localparam barr = 4'b0010;\n" + " localparam baaaaz = 4'b0111;\n" + "endpackage\n"}, + {// parameter alignment in module body + "module m;\n" + "parameter int foo = 1;\n" + "parameter int barr = 2;\n" + "endmodule\n", + "module m;\n" + " parameter int foo = 1;\n" + " parameter int barr = 2;\n" + "endmodule\n"}, + {// parameter alignment in package body + "package p;\n" + "parameter int foo = 1;\n" + "parameter int barrrr = 2;\n" + "endpackage\n", + "package p;\n" + " parameter int foo = 1;\n" + " parameter int barrrr = 2;\n" + "endpackage\n"}, + }; + FormatStyle style; + style.column_limit = 40; + style.indentation_spaces = 2; + style.wrap_spaces = 4; + style.parameter_declaration_alignment = AlignmentPolicy::kAlign; + for (const auto &test_case : kTestCases) { + VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; + std::ostringstream stream; + const auto status = + FormatVerilog(test_case.input, "<filename>", style, stream); + EXPECT_OK(status) << status.message(); + EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; + } +} + +// Verify kFlushLeft behavior: body-level param/localparam declarations +// are not aligned. +TEST(FormatterEndToEndTest, ParamDeclarationAlignmentFlushLeft) { + static constexpr FormatterTestCase kTestCases[] = { + {// module body: parameters are not aligned + "module m;\n" + "localparam foo = 4'b0000;\n" + "localparam barr = 4'b0010;\n" + "endmodule\n", + "module m;\n" + " localparam foo = 4'b0000;\n" + " localparam barr = 4'b0010;\n" + "endmodule\n"}, + {// package context: flush-left + "package p;\n" + "localparam foo = 4'b0000;\n" + "localparam barr = 4'b0010;\n" + "endpackage\n", + "package p;\n" + " localparam foo = 4'b0000;\n" + " localparam barr = 4'b0010;\n" + "endpackage\n"}, + {// generate context: flush-left + "module m;\n" + "generate\n" + "localparam foo = 1;\n" + "localparam barr = 2;\n" + "endgenerate\n" + "endmodule\n", + "module m;\n" + " generate\n" + " localparam foo = 1;\n" + " localparam barr = 2;\n" + " endgenerate\n" + "endmodule\n"}, + {// parameter in module body: flush-left + "module m;\n" + "parameter int W = 8;\n" + "parameter int HHHH = 2;\n" + "endmodule\n", + "module m;\n" + " parameter int W = 8;\n" + " parameter int HHHH = 2;\n" + "endmodule\n"}, + {// mixed parameter and localparam: flush-left, no alignment + "module m;\n" + "parameter int W = 8;\n" + "localparam L = 4;\n" + "parameter int H = 2;\n" + "endmodule\n", + "module m;\n" + " parameter int W = 8;\n" + " localparam L = 4;\n" + " parameter int H = 2;\n" + "endmodule\n"}, + {// interface context: flush-left + "interface my_if;\n" + "localparam foo = 1;\n" + "localparam barr = 2;\n" + "endinterface\n", + "interface my_if;\n" + " localparam foo = 1;\n" + " localparam barr = 2;\n" + "endinterface\n"}, + }; + FormatStyle style; + style.column_limit = 40; + style.indentation_spaces = 2; + style.wrap_spaces = 4; + style.parameter_declaration_alignment = AlignmentPolicy::kFlushLeft; + for (const auto &test_case : kTestCases) { + VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; + std::ostringstream stream; + const auto status = + FormatVerilog(test_case.input, "<filename>", style, stream); + EXPECT_OK(status) << status.message(); + EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; + } +} + +// Verify kPreserve behavior: body-level param/localparam declarations +// maintain their existing spacing. +TEST(FormatterEndToEndTest, ParamDeclarationAlignmentPreserve) { + static constexpr FormatterTestCase kTestCases[] = { + {// module body: existing spacing is kept + "module m;\n" + "localparam foo = 4'b0000;\n" + "localparam barr = 4'b0010;\n" + "endmodule\n", + "module m;\n" + " localparam foo = 4'b0000;\n" + " localparam barr = 4'b0010;\n" + "endmodule\n"}, + {// package: existing flush-left spacing preserved + "package p;\n" + "localparam foo = 4'b0000;\n" + "localparam barr = 4'b0010;\n" + "endpackage\n", + "package p;\n" + " localparam foo = 4'b0000;\n" + " localparam barr = 4'b0010;\n" + "endpackage\n"}, + {// generate: existing aligned spacing preserved + "module m;\n" + "generate\n" + "localparam foo = 1;\n" + "localparam barr = 2;\n" + "endgenerate\n" + "endmodule\n", + "module m;\n" + " generate\n" + " localparam foo = 1;\n" + " localparam barr = 2;\n" + " endgenerate\n" + "endmodule\n"}, + {// parameter flush-left preserved + "module m;\n" + "parameter int W = 8;\n" + "parameter int HHHH = 2;\n" + "endmodule\n", + "module m;\n" + " parameter int W = 8;\n" + " parameter int HHHH = 2;\n" + "endmodule\n"}, + {// parameter pre-aligned preserved + "module m;\n" + "parameter int W = 8;\n" + "parameter int HHHH = 2;\n" + "endmodule\n", + "module m;\n" + " parameter int W = 8;\n" + " parameter int HHHH = 2;\n" + "endmodule\n"}, + {// interface pre-aligned preserved + "interface my_if;\n" + "localparam foo = 1;\n" + "localparam barr = 2;\n" + "endinterface\n", + "interface my_if;\n" + " localparam foo = 1;\n" + " localparam barr = 2;\n" + "endinterface\n"}, + }; + FormatStyle style; + style.column_limit = 40; + style.indentation_spaces = 2; + style.wrap_spaces = 4; + style.parameter_declaration_alignment = AlignmentPolicy::kPreserve; + for (const auto &test_case : kTestCases) { + VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; + std::ostringstream stream; + const auto status = + FormatVerilog(test_case.input, "<filename>", style, stream); + EXPECT_OK(status) << status.message(); + EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; + } +} + +// Verify kAlign behavior for param/localparam declarations across +// interface, generate, and module body contexts, including mixed +// param/localparam and packed dimension alignment. +TEST(FormatterEndToEndTest, ParamDeclarationAlignmentContexts) { + static constexpr FormatterTestCase kTestCases[] = { + {// interface body localparam alignment + "interface my_if;\n" + "localparam foo = 1;\n" + "localparam barr = 2;\n" + "endinterface\n", + "interface my_if;\n" + " localparam foo = 1;\n" + " localparam barr = 2;\n" + "endinterface\n"}, + {// interface body parameter alignment + "interface my_if;\n" + "parameter int X = 1;\n" + "parameter int Y_LONG = 2;\n" + "endinterface\n", + "interface my_if;\n" + " parameter int X = 1;\n" + " parameter int Y_LONG = 2;\n" + "endinterface\n"}, + {// generate block localparam alignment + "module m;\n" + "generate\n" + "localparam foo = 1;\n" + "localparam barr = 2;\n" + "endgenerate\n" + "endmodule\n", + "module m;\n" + " generate\n" + " localparam foo = 1;\n" + " localparam barr = 2;\n" + " endgenerate\n" + "endmodule\n"}, + {// generate block parameter alignment + "module m;\n" + "generate\n" + "parameter int A = 1;\n" + "parameter int BB = 2;\n" + "endgenerate\n" + "endmodule\n", + "module m;\n" + " generate\n" + " parameter int A = 1;\n" + " parameter int BB = 2;\n" + " endgenerate\n" + "endmodule\n"}, + {// mixed param and net declarations form separate alignment groups + "module m;\n" + "localparam X = 1;\n" + "localparam YYY = 2;\n" + "logic clk;\n" + "logic rst_n;\n" + "localparam ZZ = 3;\n" + "endmodule\n", + "module m;\n" + " localparam X = 1;\n" + " localparam YYY = 2;\n" + " logic clk;\n" + " logic rst_n;\n" + " localparam ZZ = 3;\n" + "endmodule\n"}, + {// mixed parameter and localparam in same block + "module m;\n" + "parameter int W = 8;\n" + "localparam L = 4;\n" + "parameter int H = 2;\n" + "endmodule\n", + "module m;\n" + " parameter int W = 8;\n" + " localparam L = 4;\n" + " parameter int H = 2;\n" + "endmodule\n"}, + {// packed dimensions are aligned + "module m;\n" + "parameter bit [7:0] X = 0;\n" + "parameter bit [31:0] YYYY = 1;\n" + "endmodule\n", + "module m;\n" + " parameter bit [ 7:0] X = 0;\n" + " parameter bit [31:0] YYYY = 1;\n" + "endmodule\n"}, + {// multi-identifier comma-separated params are not split (no-crash) + "module m;\n" + "parameter int a=1, b=2, ccc=3;\n" + "localparam d=4, e=5;\n" + "endmodule\n", + "module m;\n" + " parameter int a = 1, b = 2, ccc = 3;\n" + " localparam d = 4, e = 5;\n" + "endmodule\n"}, + {// parameter type declarations do not crash + "module m;\n" + "parameter type T = int;\n" + "parameter type TT_LONG = bit;\n" + "endmodule\n", + "module m;\n" + " parameter type T = int;\n" + " parameter type TT_LONG = bit;\n" + "endmodule\n"}, + }; + FormatStyle style; + style.column_limit = 40; + style.indentation_spaces = 2; + style.wrap_spaces = 4; + style.parameter_declaration_alignment = AlignmentPolicy::kAlign; + for (const auto &test_case : kTestCases) { + VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; + std::ostringstream stream; + const auto status = + FormatVerilog(test_case.input, "<filename>", style, stream); + EXPECT_OK(status) << status.message(); + EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; + } +} + +// Verify kInferUserIntent behavior: body-level param/localparam +// declarations infer alignment intent from existing spacing. +TEST(FormatterEndToEndTest, ParamDeclarationAlignmentInferUserIntent) { + static constexpr FormatterTestCase kTestCases[] = { + {// flush-left localparams with small spacing diff: infer aligns + "module m;\n" + "localparam foo = 1;\n" + "localparam barr = 2;\n" + "endmodule\n", + "module m;\n" + " localparam foo = 1;\n" + " localparam barr = 2;\n" + "endmodule\n"}, + {// pre-aligned localparams: infer preserves alignment + "module m;\n" + "localparam foo = 1;\n" + "localparam barr = 2;\n" + "localparam baaaaz = 3;\n" + "endmodule\n", + "module m;\n" + " localparam foo = 1;\n" + " localparam barr = 2;\n" + " localparam baaaaz = 3;\n" + "endmodule\n"}, + {// flush-left params in package with small spacing diff: infer aligns + "package p;\n" + "localparam X = 1;\n" + "localparam YY = 2;\n" + "endpackage\n", + "package p;\n" + " localparam X = 1;\n" + " localparam YY = 2;\n" + "endpackage\n"}, + {// mixed param/localparam flush-left: infer keeps flush-left + "module m;\n" + "parameter int W = 8;\n" + "localparam L = 4;\n" + "endmodule\n", + "module m;\n" + " parameter int W = 8;\n" + " localparam L = 4;\n" + "endmodule\n"}, + {// interface flush-left with small diff: infer aligns + "interface my_if;\n" + "localparam foo = 1;\n" + "localparam barr = 2;\n" + "endinterface\n", + "interface my_if;\n" + " localparam foo = 1;\n" + " localparam barr = 2;\n" + "endinterface\n"}, + }; + FormatStyle style; + style.column_limit = 40; + style.indentation_spaces = 2; + style.wrap_spaces = 4; + style.parameter_declaration_alignment = AlignmentPolicy::kInferUserIntent; + for (const auto &test_case : kTestCases) { + VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; + std::ostringstream stream; + const auto status = + FormatVerilog(test_case.input, "<filename>", style, stream); + EXPECT_OK(status) << status.message(); + EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; + } +} + +// Verify boundary behavior for param declarations with +// kBlankLinesAndSeparatorComments: both blank lines and separator comments +// break alignment groups. +TEST(FormatterEndToEndTest, ParamDeclarationAlignmentBoundary) { + static constexpr FormatterTestCase kTestCases[] = { + {// separator comment breaks param alignment group + "module m;\n" + "localparam foo = 1;\n" + "localparam barr = 2;\n" + "// ============\n" + "localparam baaaaz = 1;\n" + "localparam c = 2;\n" + "endmodule\n", + "module m;\n" + " localparam foo = 1;\n" + " localparam barr = 2;\n" + " // ============\n" + " localparam baaaaz = 1;\n" + " localparam c = 2;\n" + "endmodule\n"}, + {// blank line breaks param alignment group + "module m;\n" + "localparam foo = 1;\n" + "localparam barr = 2;\n" + "\n" + "localparam baaaaz = 1;\n" + "localparam c = 2;\n" + "endmodule\n", + "module m;\n" + " localparam foo = 1;\n" + " localparam barr = 2;\n" + "\n" + " localparam baaaaz = 1;\n" + " localparam c = 2;\n" + "endmodule\n"}, + {// no separator: single alignment group (all aligned together) + "module m;\n" + "localparam foo = 1;\n" + "localparam barr = 2;\n" + "localparam baaaaz = 1;\n" + "localparam c = 2;\n" + "endmodule\n", + "module m;\n" + " localparam foo = 1;\n" + " localparam barr = 2;\n" + " localparam baaaaz = 1;\n" + " localparam c = 2;\n" + "endmodule\n"}, + {// regular comment does NOT break alignment group + "module m;\n" + "localparam foo = 1;\n" + "// regular comment\n" + "localparam barr = 2;\n" + "localparam baaaaz = 1;\n" + "endmodule\n", + "module m;\n" + " localparam foo = 1;\n" + " // regular comment\n" + " localparam barr = 2;\n" + " localparam baaaaz = 1;\n" + "endmodule\n"}, + }; + FormatStyle style; + style.column_limit = 40; + style.indentation_spaces = 2; + style.wrap_spaces = 4; + style.parameter_declaration_alignment = AlignmentPolicy::kAlign; + style.alignment_group_boundary = + AlignmentGroupBoundary::kBlankLinesAndSeparatorComments; + for (const auto &test_case : kTestCases) { + VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; + std::ostringstream stream; + const auto status = + FormatVerilog(test_case.input, "<filename>", style, stream); + EXPECT_OK(status) << status.message(); + EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; + } +} + +// Verify edge cases: unpacked dimensions, signed/unsigned, implicit types, +// complex types, single declarations, deeply nested generate blocks. +TEST(FormatterEndToEndTest, ParamDeclarationAlignmentEdgeCases) { + // Use column_limit = 80 to avoid unintended line wrapping inside + // deeply nested generate blocks (generate-if, generate-for), which + // would interfere with verifying alignment behavior. + static constexpr FormatterTestCase kTestCases[] = { + {// unpacked dimension alignment + "module m;\n" + "parameter bit X [7:0] = 0;\n" + "parameter bit YYYY [15:0] = 1;\n" + "endmodule\n", + "module m;\n" + " parameter bit X [ 7:0] = 0;\n" + " parameter bit YYYY[15:0] = 1;\n" + "endmodule\n"}, + {// param declarations with only type and default value (no idim) + "module m;\n" + "parameter int X = 0;\n" + "parameter int YYYY = 0;\n" + "endmodule\n", + "module m;\n" + " parameter int X = 0;\n" + " parameter int YYYY = 0;\n" + "endmodule\n"}, + {// signed modifier with packed dimensions + "module m;\n" + "parameter bit signed [7:0] X = 0;\n" + "parameter bit signed [31:0] YYYY = 1;\n" + "endmodule\n", + "module m;\n" + " parameter bit signed [ 7:0] X = 0;\n" + " parameter bit signed [31:0] YYYY = 1;\n" + "endmodule\n"}, + {// param with complex type (struct/typedef) — does not crash + "module m;\n" + "parameter foo_t X = foo_t'(0);\n" + "parameter foo_t Y_LONG = foo_t'(0);\n" + "endmodule\n", + "module m;\n" + " parameter foo_t X = foo_t'(0);\n" + " parameter foo_t Y_LONG = foo_t'(0);\n" + "endmodule\n"}, + {// single param declaration (not enough for alignment group) + "module m;\n" + "localparam X = 1;\n" + "endmodule\n", + "module m;\n" + " localparam X = 1;\n" + "endmodule\n"}, + {// params inside generate-if block + "module m;\n" + "generate\n" + "if (1) begin : blk\n" + "localparam foo = 1;\n" + "localparam barr = 2;\n" + "end\n" + "endgenerate\n" + "endmodule\n", + "module m;\n" + " generate\n" + " if (1) begin : blk\n" + " localparam foo = 1;\n" + " localparam barr = 2;\n" + " end\n" + " endgenerate\n" + "endmodule\n"}, + {// unsigned keyword with packed dimensions (complement to signed) + "module m;\n" + "parameter bit unsigned [7:0] X = 0;\n" + "parameter bit unsigned [31:0] YYYY = 1;\n" + "endmodule\n", + "module m;\n" + " parameter bit unsigned [ 7:0] X = 0;\n" + " parameter bit unsigned [31:0] YYYY = 1;\n" + "endmodule\n"}, + {// parameter with implicit type (no explicit type keyword) + "module m;\n" + "parameter X = 32;\n" + "parameter Y_LONG = 64;\n" + "endmodule\n", + "module m;\n" + " parameter X = 32;\n" + " parameter Y_LONG = 64;\n" + "endmodule\n"}, + {// params inside generate-for block + "module m;\n" + "generate\n" + "for (i = 0; i < 2; i++) begin : blk\n" + "localparam foo = 1;\n" + "localparam barr = 2;\n" + "end\n" + "endgenerate\n" + "endmodule\n", + "module m;\n" + " generate\n" + " for (i = 0; i < 2; i++) begin : blk\n" + " localparam foo = 1;\n" + " localparam barr = 2;\n" + " end\n" + " endgenerate\n" + "endmodule\n"}, + }; + FormatStyle style; + style.column_limit = 80; + style.indentation_spaces = 2; + style.wrap_spaces = 4; + style.parameter_declaration_alignment = AlignmentPolicy::kAlign; + for (const auto &test_case : kTestCases) { + VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; + std::ostringstream stream; + const auto status = + FormatVerilog(test_case.input, "<filename>", style, stream); + EXPECT_OK(status) << status.message(); + EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; + } +} + +// Verify parameter declarations inside generate-case blocks are aligned. +TEST(FormatterEndToEndTest, ParamDeclarationAlignmentGenerateCase) { + // Params inside generate-case need wider column limit to avoid wrapping the + // case label / begin block line. + static constexpr FormatterTestCase kTestCases[] = { + {// params inside generate-case block + "module m #(P = 0);\n" + "generate\n" + "case (P)\n" + "0: begin : blk\n" + "localparam foo = 1;\n" + "localparam barr = 2;\n" + "end\n" + "endcase\n" + "endgenerate\n" + "endmodule\n", + "module m #(\n" + " P = 0\n" + ");\n" + " generate\n" + " case (P)\n" + " 0: begin : blk\n" + " localparam foo = 1;\n" + " localparam barr = 2;\n" + " end\n" + " endcase\n" + " endgenerate\n" + "endmodule\n"}, + }; + FormatStyle style; + style.column_limit = 80; + style.indentation_spaces = 2; + style.wrap_spaces = 4; + style.parameter_declaration_alignment = AlignmentPolicy::kAlign; + for (const auto &test_case : kTestCases) { + VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; + std::ostringstream stream; + const auto status = + FormatVerilog(test_case.input, "<filename>", style, stream); + EXPECT_OK(status) << status.message(); + EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; + } +} + +TEST(FormatterEndToEndTest, FormalAndBodyParamAlignmentIndependence) { + // Verify that --formal_parameters_alignment and + // --parameter_declaration_alignment act independently: setting formal params + // to kFlushLeft should not affect body-level param alignment, and vice versa. + static constexpr FormatterTestCase kTestCases[] = { + {// formal flush-left + body align: only body params align + "module m #(\n" + "int W = 2,\n" + "int LLLL = 4\n" + ");\n" + "localparam foo = 0;\n" + "localparam barrrr = 0;\n" + "endmodule\n", + "module m #(\n" + " int W = 2,\n" + " int LLLL = 4\n" + ");\n" + " localparam foo = 0;\n" + " localparam barrrr = 0;\n" + "endmodule\n"}, + {// formal align + body flush-left: only formal params align + "module m #(\n" + "int W = 2,\n" + "int LLLL = 4\n" + ");\n" + "localparam foo = 0;\n" + "localparam barrrr = 0;\n" + "endmodule\n", + "module m #(\n" + " int W = 2,\n" + " int LLLL = 4\n" + ");\n" + " localparam foo = 0;\n" + " localparam barrrr = 0;\n" + "endmodule\n"}, + {// both flush-left: no alignment anywhere + "module m #(\n" + "int W = 2,\n" + "int LLLL = 4\n" + ");\n" + "localparam foo = 0;\n" + "localparam barrrr = 0;\n" + "endmodule\n", + "module m #(\n" + " int W = 2,\n" + " int LLLL = 4\n" + ");\n" + " localparam foo = 0;\n" + " localparam barrrr = 0;\n" + "endmodule\n"}, + {// both align: both formal and body params aligned + "module m #(\n" + "int W = 2,\n" + "int LLLL = 4\n" + ");\n" + "localparam foo = 0;\n" + "localparam barrrr = 0;\n" + "endmodule\n", + "module m #(\n" + " int W = 2,\n" + " int LLLL = 4\n" + ");\n" + " localparam foo = 0;\n" + " localparam barrrr = 0;\n" + "endmodule\n"}, + }; + // First case: formal kFlushLeft, body kAlign + { + FormatStyle style; + style.column_limit = 40; + style.indentation_spaces = 2; + style.wrap_spaces = 4; + style.parameter_declaration_alignment = AlignmentPolicy::kAlign; + style.formal_parameters_alignment = AlignmentPolicy::kFlushLeft; + const auto &tc = kTestCases[0]; + VLOG(1) << "code-to-format:\n" << tc.input << "<EOF>"; + std::ostringstream stream; + const auto status = FormatVerilog(tc.input, "<filename>", style, stream); + EXPECT_OK(status) << status.message(); + EXPECT_EQ(stream.str(), tc.expected) << "code:\n" << tc.input; + } + // Second case: formal kAlign, body kFlushLeft + { + FormatStyle style; + style.column_limit = 40; + style.indentation_spaces = 2; + style.wrap_spaces = 4; + style.parameter_declaration_alignment = AlignmentPolicy::kFlushLeft; + style.formal_parameters_alignment = AlignmentPolicy::kAlign; + const auto &tc = kTestCases[1]; + VLOG(1) << "code-to-format:\n" << tc.input << "<EOF>"; + std::ostringstream stream; + const auto status = FormatVerilog(tc.input, "<filename>", style, stream); + EXPECT_OK(status) << status.message(); + EXPECT_EQ(stream.str(), tc.expected) << "code:\n" << tc.input; + } + // Third case: both kFlushLeft + { + FormatStyle style; + style.column_limit = 40; + style.indentation_spaces = 2; + style.wrap_spaces = 4; + style.parameter_declaration_alignment = AlignmentPolicy::kFlushLeft; + style.formal_parameters_alignment = AlignmentPolicy::kFlushLeft; + const auto &tc = kTestCases[2]; + VLOG(1) << "code-to-format:\n" << tc.input << "<EOF>"; + std::ostringstream stream; + const auto status = FormatVerilog(tc.input, "<filename>", style, stream); + EXPECT_OK(status) << status.message(); + EXPECT_EQ(stream.str(), tc.expected) << "code:\n" << tc.input; + } + // Fourth case: both kAlign + { + FormatStyle style; + style.column_limit = 40; + style.indentation_spaces = 2; + style.wrap_spaces = 4; + style.parameter_declaration_alignment = AlignmentPolicy::kAlign; + style.formal_parameters_alignment = AlignmentPolicy::kAlign; + const auto &tc = kTestCases[3]; + VLOG(1) << "code-to-format:\n" << tc.input << "<EOF>"; + std::ostringstream stream; + const auto status = FormatVerilog(tc.input, "<filename>", style, stream); + EXPECT_OK(status) << status.message(); + EXPECT_EQ(stream.str(), tc.expected) << "code:\n" << tc.input; + } +} + +TEST(FormatterEndToEndTest, ClassBodyParamNotAffected) { + // Verify that class body parameter/localparam declarations are NOT affected + // by --parameter_declaration_alignment, which targets only module/generate/ + // package/interface body-level params. + static constexpr FormatterTestCase kTestCases[] = { + {// class body params are not affected + "class c;\n" + "parameter int X = 1;\n" + "parameter int YYYY = 2;\n" + "localparam foo = 3;\n" + "localparam barrrr = 4;\n" + "endclass\n", + "class c;\n" + " parameter int X = 1;\n" + " parameter int YYYY = 2;\n" + " localparam foo = 3;\n" + " localparam barrrr = 4;\n" + "endclass\n"}, + }; + FormatStyle style; + style.column_limit = 40; + style.indentation_spaces = 2; + style.wrap_spaces = 4; + style.parameter_declaration_alignment = AlignmentPolicy::kAlign; + for (const auto &test_case : kTestCases) { + VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; + std::ostringstream stream; + const auto status = + FormatVerilog(test_case.input, "<filename>", style, stream); + EXPECT_OK(status) << status.message(); + EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; + } +} + +TEST(FormatterEndToEndTest, PackageBodyVariableAlignment) { + // Verify that moving kPackageItemList to kTabularAlignment in tree-unwrapper + // enables net/variable declaration alignment in package bodies via + // module_net_variable_alignment. + static constexpr FormatterTestCase kTestCases[] = { + {// net/variable declaration alignment in package body + "package p;\n" + "logic [7:0] a;\n" + "logic [31:0] bb;\n" + "endpackage\n", + "package p;\n" + " logic [ 7:0] a;\n" + " logic [31:0] bb;\n" + "endpackage\n"}, + }; + FormatStyle style; + style.column_limit = 40; + style.indentation_spaces = 2; + style.wrap_spaces = 4; + style.module_net_variable_alignment = AlignmentPolicy::kAlign; + for (const auto &test_case : kTestCases) { + VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; + std::ostringstream stream; + const auto status = + FormatVerilog(test_case.input, "<filename>", style, stream); + EXPECT_OK(status) << status.message(); + EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; + } +} + +TEST(FormatterEndToEndTest, ParamDeclarationAlignmentApplyToAll) { + // Verify that ApplyToAllAlignmentPolicies affects + // parameter_declaration_alignment for all four alignment policies. + static constexpr FormatterTestCase kTestCases[] = { + {// kAlign aligns identifiers and = signs across declarations + "module m;\n" + "localparam foo = 1;\n" + "localparam barrrr = 2;\n" + "endmodule\n", + "module m;\n" + " localparam foo = 1;\n" + " localparam barrrr = 2;\n" + "endmodule\n"}, + {// kFlushLeft: declarations remain flush-left + "module m;\n" + "localparam foo = 1;\n" + "localparam barrrr = 2;\n" + "endmodule\n", + "module m;\n" + " localparam foo = 1;\n" + " localparam barrrr = 2;\n" + "endmodule\n"}, + {// kPreserve: existing spacing is kept + "module m;\n" + "localparam foo = 1;\n" + "localparam barrrr = 2;\n" + "endmodule\n", + "module m;\n" + " localparam foo = 1;\n" + " localparam barrrr = 2;\n" + "endmodule\n"}, + {// kInferUserIntent: large identifier width difference (3 cols) + // suggests flush-left intent, no alignment. + "module m;\n" + "localparam foo = 1;\n" + "localparam barrrr = 2;\n" + "endmodule\n", + "module m;\n" + " localparam foo = 1;\n" + " localparam barrrr = 2;\n" + "endmodule\n"}, + }; + // kAlign + { + FormatStyle style; + style.column_limit = 40; + style.indentation_spaces = 2; + style.wrap_spaces = 4; + style.ApplyToAllAlignmentPolicies(AlignmentPolicy::kAlign); + const auto &tc = kTestCases[0]; + std::ostringstream stream; + const auto status = FormatVerilog(tc.input, "<filename>", style, stream); + EXPECT_OK(status) << status.message(); + EXPECT_EQ(stream.str(), tc.expected) << "code:\n" << tc.input; + } + // kFlushLeft + { + FormatStyle style; + style.column_limit = 40; + style.indentation_spaces = 2; + style.wrap_spaces = 4; + style.ApplyToAllAlignmentPolicies(AlignmentPolicy::kFlushLeft); + const auto &tc = kTestCases[1]; + std::ostringstream stream; + const auto status = FormatVerilog(tc.input, "<filename>", style, stream); + EXPECT_OK(status) << status.message(); + EXPECT_EQ(stream.str(), tc.expected) << "code:\n" << tc.input; + } + // kPreserve + { + FormatStyle style; + style.column_limit = 40; + style.indentation_spaces = 2; + style.wrap_spaces = 4; + style.ApplyToAllAlignmentPolicies(AlignmentPolicy::kPreserve); + const auto &tc = kTestCases[2]; + std::ostringstream stream; + const auto status = FormatVerilog(tc.input, "<filename>", style, stream); + EXPECT_OK(status) << status.message(); + EXPECT_EQ(stream.str(), tc.expected) << "code:\n" << tc.input; + } + // kInferUserIntent + { + FormatStyle style; + style.column_limit = 40; + style.indentation_spaces = 2; + style.wrap_spaces = 4; + style.ApplyToAllAlignmentPolicies(AlignmentPolicy::kInferUserIntent); + const auto &tc = kTestCases[3]; + std::ostringstream stream; + const auto status = FormatVerilog(tc.input, "<filename>", style, stream); + EXPECT_OK(status) << status.message(); + EXPECT_EQ(stream.str(), tc.expected) << "code:\n" << tc.input; + } +} + +// Verify that alignment_group_boundary=kBlankLines treats only blank lines +// (not separator comments) as boundary breaks for param declarations. +TEST(FormatterEndToEndTest, ParamDeclarationAlignmentBoundaryBlankLines) { + static constexpr FormatterTestCase kTestCases[] = { + {// Only blank line breaks group; separator comment does not + "module m;\n" + "localparam foo = 1;\n" + "localparam barr = 2;\n" + "\n" + "localparam baaaaz = 1;\n" + "localparam c = 2;\n" + "endmodule\n", + "module m;\n" + " localparam foo = 1;\n" + " localparam barr = 2;\n" + "\n" + " localparam baaaaz = 1;\n" + " localparam c = 2;\n" + "endmodule\n"}, + {// Separator comment does NOT break group with kBlankLines + "module m;\n" + "localparam foo = 1;\n" + "localparam barr = 2;\n" + "// ============\n" + "localparam baaaaz = 1;\n" + "localparam c = 2;\n" + "endmodule\n", + "module m;\n" + " localparam foo = 1;\n" + " localparam barr = 2;\n" + " // ============\n" + " localparam baaaaz = 1;\n" + " localparam c = 2;\n" + "endmodule\n"}, + }; + FormatStyle style; + style.column_limit = 40; + style.indentation_spaces = 2; + style.wrap_spaces = 4; + style.parameter_declaration_alignment = AlignmentPolicy::kAlign; + style.alignment_group_boundary = AlignmentGroupBoundary::kBlankLines; + for (const auto &test_case : kTestCases) { + VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; + std::ostringstream stream; + const auto status = + FormatVerilog(test_case.input, "<filename>", style, stream); + EXPECT_OK(status) << status.message(); + EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; + } +} + +// Verify that alignment_group_boundary=kNone keeps all param declarations +// in a single alignment group regardless of blank lines or comments. +TEST(FormatterEndToEndTest, ParamDeclarationAlignmentBoundaryNone) { + static constexpr FormatterTestCase kTestCases[] = { + {// Blank line does NOT break group with kNone + "module m;\n" + "localparam foo = 1;\n" + "localparam barr = 2;\n" + "\n" + "localparam baaaaz = 1;\n" + "localparam c = 2;\n" + "endmodule\n", + "module m;\n" + " localparam foo = 1;\n" + " localparam barr = 2;\n" + "\n" + " localparam baaaaz = 1;\n" + " localparam c = 2;\n" + "endmodule\n"}, + {// Separator comment does NOT break group with kNone + "module m;\n" + "localparam foo = 1;\n" + "localparam barr = 2;\n" + "// ============\n" + "localparam baaaaz = 1;\n" + "localparam c = 2;\n" + "endmodule\n", + "module m;\n" + " localparam foo = 1;\n" + " localparam barr = 2;\n" + " // ============\n" + " localparam baaaaz = 1;\n" + " localparam c = 2;\n" + "endmodule\n"}, + }; + FormatStyle style; + style.column_limit = 40; + style.indentation_spaces = 2; + style.wrap_spaces = 4; + style.parameter_declaration_alignment = AlignmentPolicy::kAlign; + style.alignment_group_boundary = AlignmentGroupBoundary::kNone; + for (const auto &test_case : kTestCases) { + VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; + std::ostringstream stream; + const auto status = + FormatVerilog(test_case.input, "<filename>", style, stream); + EXPECT_OK(status) << status.message(); + EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; + } +} + +// Verify that alignment_group_boundary=kSeparatorComments treats only +// separator comments (not blank lines) as boundary breaks for param +// declarations. +TEST(FormatterEndToEndTest, + ParamDeclarationAlignmentBoundarySeparatorComments) { + static constexpr FormatterTestCase kTestCases[] = { + {// Separator comment breaks alignment group + "module m;\n" + "localparam foo = 1;\n" + "localparam barr = 2;\n" + "// ============\n" + "localparam baaaaz = 1;\n" + "localparam c = 2;\n" + "endmodule\n", + "module m;\n" + " localparam foo = 1;\n" + " localparam barr = 2;\n" + " // ============\n" + " localparam baaaaz = 1;\n" + " localparam c = 2;\n" + "endmodule\n"}, + {// Blank line does NOT break group with kSeparatorComments + "module m;\n" + "localparam foo = 1;\n" + "localparam barr = 2;\n" + "\n" + "localparam baaaaz = 1;\n" + "localparam c = 2;\n" + "endmodule\n", + "module m;\n" + " localparam foo = 1;\n" + " localparam barr = 2;\n" + "\n" + " localparam baaaaz = 1;\n" + " localparam c = 2;\n" + "endmodule\n"}, + }; + FormatStyle style; + style.column_limit = 40; + style.indentation_spaces = 2; + style.wrap_spaces = 4; + style.parameter_declaration_alignment = AlignmentPolicy::kAlign; + style.alignment_group_boundary = AlignmentGroupBoundary::kSeparatorComments; + for (const auto &test_case : kTestCases) { + VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; + std::ostringstream stream; + const auto status = + FormatVerilog(test_case.input, "<filename>", style, stream); + EXPECT_OK(status) << status.message(); + EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; + } +} + +// Verify that class body parameter/localparam declarations are NOT affected +// by --parameter_declaration_alignment for the kFlushLeft, kPreserve, +// and kInferUserIntent policies (kAlign is covered in +// ClassBodyParamNotAffected). +TEST(FormatterEndToEndTest, ClassBodyParamNotAffectedOtherPolicies) { + static constexpr FormatterTestCase kTestCases[] = { + {// kFlushLeft: class body params remain flush-left + "class c;\n" + "parameter int X = 1;\n" + "parameter int YYYY = 2;\n" + "localparam foo = 3;\n" + "localparam barrrr = 4;\n" + "endclass\n", + "class c;\n" + " parameter int X = 1;\n" + " parameter int YYYY = 2;\n" + " localparam foo = 3;\n" + " localparam barrrr = 4;\n" + "endclass\n"}, + {// kPreserve: parameter_declaration_alignment does not apply to class + // bodies; whitespace is normalized by default formatting. + "class c;\n" + "parameter int X = 1;\n" + "parameter int YYYY = 2;\n" + "endclass\n", + "class c;\n" + " parameter int X = 1;\n" + " parameter int YYYY = 2;\n" + "endclass\n"}, + {// kInferUserIntent: class body params infer flush-left + "class c;\n" + "parameter int X = 1;\n" + "parameter int YYYY = 2;\n" + "endclass\n", + "class c;\n" + " parameter int X = 1;\n" + " parameter int YYYY = 2;\n" + "endclass\n"}, + }; + // kFlushLeft + { + FormatStyle style; + style.column_limit = 40; + style.indentation_spaces = 2; + style.wrap_spaces = 4; + style.parameter_declaration_alignment = AlignmentPolicy::kFlushLeft; + const auto &tc = kTestCases[0]; + std::ostringstream stream; + const auto status = FormatVerilog(tc.input, "<filename>", style, stream); + EXPECT_OK(status) << status.message(); + EXPECT_EQ(stream.str(), tc.expected) << "code:\n" << tc.input; + } + // kPreserve + { + FormatStyle style; + style.column_limit = 40; + style.indentation_spaces = 2; + style.wrap_spaces = 4; + style.parameter_declaration_alignment = AlignmentPolicy::kPreserve; + const auto &tc = kTestCases[1]; + std::ostringstream stream; + const auto status = FormatVerilog(tc.input, "<filename>", style, stream); + EXPECT_OK(status) << status.message(); + EXPECT_EQ(stream.str(), tc.expected) << "code:\n" << tc.input; + } + // kInferUserIntent + { + FormatStyle style; + style.column_limit = 40; + style.indentation_spaces = 2; + style.wrap_spaces = 4; + style.parameter_declaration_alignment = AlignmentPolicy::kInferUserIntent; + const auto &tc = kTestCases[2]; + std::ostringstream stream; + const auto status = FormatVerilog(tc.input, "<filename>", style, stream); + EXPECT_OK(status) << status.message(); + EXPECT_EQ(stream.str(), tc.expected) << "code:\n" << tc.input; + } +} + +// Verify formal_parameters_alignment and parameter_declaration_alignment +// independence for kPreserve and kInferUserIntent combinations. +TEST(FormatterEndToEndTest, + FormalAndBodyParamAlignmentIndependenceOtherPolicies) { + static constexpr FormatterTestCase kTestCases[] = { + {// formal kPreserve + body kAlign: only body params aligned + "module m #(\n" + "int W = 2,\n" + "int LLLL = 4\n" + ");\n" + "localparam foo = 0;\n" + "localparam barrrr = 0;\n" + "endmodule\n", + "module m #(\n" + " int W = 2,\n" + " int LLLL = 4\n" + ");\n" + " localparam foo = 0;\n" + " localparam barrrr = 0;\n" + "endmodule\n"}, + {// formal kAlign + body kPreserve: only formal params aligned + "module m #(\n" + "int W = 2,\n" + "int LLLL = 4\n" + ");\n" + "localparam foo = 0;\n" + "localparam barrrr = 0;\n" + "endmodule\n", + "module m #(\n" + " int W = 2,\n" + " int LLLL = 4\n" + ");\n" + " localparam foo = 0;\n" + " localparam barrrr = 0;\n" + "endmodule\n"}, + {// formal kInferUserIntent + body kAlign: only body params aligned + "module m #(\n" + "int W = 2,\n" + "int LLLL = 4\n" + ");\n" + "localparam foo = 0;\n" + "localparam barrrr = 0;\n" + "endmodule\n", + "module m #(\n" + " int W = 2,\n" + " int LLLL = 4\n" + ");\n" + " localparam foo = 0;\n" + " localparam barrrr = 0;\n" + "endmodule\n"}, + }; + // formal kPreserve + body kAlign + { + FormatStyle style; + style.column_limit = 40; + style.indentation_spaces = 2; + style.wrap_spaces = 4; + style.parameter_declaration_alignment = AlignmentPolicy::kAlign; + style.formal_parameters_alignment = AlignmentPolicy::kPreserve; + const auto &tc = kTestCases[0]; + std::ostringstream stream; + const auto status = FormatVerilog(tc.input, "<filename>", style, stream); + EXPECT_OK(status) << status.message(); + EXPECT_EQ(stream.str(), tc.expected) << "code:\n" << tc.input; + } + // formal kAlign + body kPreserve + { + FormatStyle style; + style.column_limit = 40; + style.indentation_spaces = 2; + style.wrap_spaces = 4; + style.parameter_declaration_alignment = AlignmentPolicy::kPreserve; + style.formal_parameters_alignment = AlignmentPolicy::kAlign; + const auto &tc = kTestCases[1]; + std::ostringstream stream; + const auto status = FormatVerilog(tc.input, "<filename>", style, stream); + EXPECT_OK(status) << status.message(); + EXPECT_EQ(stream.str(), tc.expected) << "code:\n" << tc.input; + } + // formal kInferUserIntent + body kAlign + { + FormatStyle style; + style.column_limit = 40; + style.indentation_spaces = 2; + style.wrap_spaces = 4; + style.parameter_declaration_alignment = AlignmentPolicy::kAlign; + style.formal_parameters_alignment = AlignmentPolicy::kInferUserIntent; + const auto &tc = kTestCases[2]; + std::ostringstream stream; + const auto status = FormatVerilog(tc.input, "<filename>", style, stream); + EXPECT_OK(status) << status.message(); + EXPECT_EQ(stream.str(), tc.expected) << "code:\n" << tc.input; + } +} + +// Verify parameter declarations with string, real, and function-call default +// value types to exercise the ColumnSchemaScanner on non-standard type tokens. +TEST(FormatterEndToEndTest, ParamDeclarationAlignmentTypeVariants) { + static constexpr FormatterTestCase kTestCases[] = { + {// parameter real type + "module m;\n" + "parameter real X = 1.0;\n" + "parameter real Y_LONG = 2.0;\n" + "endmodule\n", + "module m;\n" + " parameter real X = 1.0;\n" + " parameter real Y_LONG = 2.0;\n" + "endmodule\n"}, + {// parameter string type + "module m;\n" + "parameter string s = \"hello\";\n" + "parameter string long_s = \"world\";\n" + "endmodule\n", + "module m;\n" + " parameter string s = \"hello\";\n" + " parameter string long_s = \"world\";\n" + "endmodule\n"}, + {// parameter with function call in default value + "module m;\n" + "parameter int W = func(1, 2);\n" + "parameter int H_LONG = other(3);\n" + "endmodule\n", + "module m;\n" + " parameter int W = func(1, 2);\n" + " parameter int H_LONG = other(3);\n" + "endmodule\n"}, + }; + FormatStyle style; + style.column_limit = 40; + style.indentation_spaces = 2; + style.wrap_spaces = 4; + style.parameter_declaration_alignment = AlignmentPolicy::kAlign; + for (const auto &test_case : kTestCases) { + VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; + std::ostringstream stream; + const auto status = + FormatVerilog(test_case.input, "<filename>", style, stream); + EXPECT_OK(status) << status.message(); + EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; + } +} + +// Verify parameter_declaration_alignment kInferUserIntent in package bodies. +TEST(FormatterEndToEndTest, ParamDeclarationAlignmentPackageInfer) { + static constexpr FormatterTestCase kTestCases[] = { + {// flush-left params with small diff: infer aligns + "package p;\n" + "localparam foo = 1;\n" + "localparam barr = 2;\n" + "endpackage\n", + "package p;\n" + " localparam foo = 1;\n" + " localparam barr = 2;\n" + "endpackage\n"}, + {// pre-aligned params: infer preserves + "package p;\n" + "localparam foo = 1;\n" + "localparam barr = 2;\n" + "localparam baaaaz = 3;\n" + "endpackage\n", + "package p;\n" + " localparam foo = 1;\n" + " localparam barr = 2;\n" + " localparam baaaaz = 3;\n" + "endpackage\n"}, + }; + FormatStyle style; + style.column_limit = 40; + style.indentation_spaces = 2; + style.wrap_spaces = 4; + style.parameter_declaration_alignment = AlignmentPolicy::kInferUserIntent; + for (const auto &test_case : kTestCases) { + VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; + std::ostringstream stream; + const auto status = + FormatVerilog(test_case.input, "<filename>", style, stream); + EXPECT_OK(status) << status.message(); + EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; + } +} + +// Verify parameter_declaration_alignment boundary behavior in package bodies. +TEST(FormatterEndToEndTest, ParamDeclarationAlignmentPackageBoundary) { + static constexpr FormatterTestCase kTestCases[] = { + {// blank line breaks alignment group in package + "package p;\n" + "localparam foo = 1;\n" + "localparam barr = 2;\n" + "\n" + "localparam baaaaz = 1;\n" + "localparam c = 2;\n" + "endpackage\n", + "package p;\n" + " localparam foo = 1;\n" + " localparam barr = 2;\n" + "\n" + " localparam baaaaz = 1;\n" + " localparam c = 2;\n" + "endpackage\n"}, + {// separator comment breaks alignment group in package + "package p;\n" + "localparam foo = 1;\n" + "localparam barr = 2;\n" + "// ============\n" + "localparam baaaaz = 1;\n" + "localparam c = 2;\n" + "endpackage\n", + "package p;\n" + " localparam foo = 1;\n" + " localparam barr = 2;\n" + " // ============\n" + " localparam baaaaz = 1;\n" + " localparam c = 2;\n" + "endpackage\n"}, + }; + FormatStyle style; + style.column_limit = 40; + style.indentation_spaces = 2; + style.wrap_spaces = 4; + style.parameter_declaration_alignment = AlignmentPolicy::kAlign; + style.alignment_group_boundary = + AlignmentGroupBoundary::kBlankLinesAndSeparatorComments; + for (const auto &test_case : kTestCases) { + VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; + std::ostringstream stream; + const auto status = + FormatVerilog(test_case.input, "<filename>", style, stream); + EXPECT_OK(status) << status.message(); + EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; + } +} + +// Verify the most common default scenario: both formal_parameters_alignment +// and parameter_declaration_alignment set to kInferUserIntent. +TEST(FormatterEndToEndTest, BothParamAlignmentsInferUserIntent) { + static constexpr FormatterTestCase kTestCases[] = { + {// both flush-left with small diff: infer aligns both formal and body + "module m #(\n" + "int W = 2,\n" + "int LL = 4\n" + ");\n" + "localparam foo = 0;\n" + "localparam barr = 0;\n" + "endmodule\n", + "module m #(\n" + " int W = 2,\n" + " int LL = 4\n" + ");\n" + " localparam foo = 0;\n" + " localparam barr = 0;\n" + "endmodule\n"}, + {// both infer: pre-aligned formal, pre-aligned body preserved + "module m #(\n" + "int W = 2,\n" + "int LLLL = 4\n" + ");\n" + "localparam foo = 0;\n" + "localparam barrrr = 0;\n" + "endmodule\n", + "module m #(\n" + " int W = 2,\n" + " int LLLL = 4\n" + ");\n" + " localparam foo = 0;\n" + " localparam barrrr = 0;\n" + "endmodule\n"}, + }; + FormatStyle style; + style.column_limit = 40; + style.indentation_spaces = 2; + style.wrap_spaces = 4; + style.parameter_declaration_alignment = AlignmentPolicy::kInferUserIntent; + style.formal_parameters_alignment = AlignmentPolicy::kInferUserIntent; + for (const auto &test_case : kTestCases) { + VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; + std::ostringstream stream; + const auto status = + FormatVerilog(test_case.input, "<filename>", style, stream); + EXPECT_OK(status) << status.message(); + EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; + } +} + +// Verify that a large multi-line comment block between parameter +// declarations does not crash the formatter. The tree-unwrapper may +// produce a partition structure where the comment tokens are absorbed +// into the following parameter partition, which the alignment code +// must handle gracefully by skipping alignment for that row. +TEST(FormatterEndToEndTest, ParamDeclarationAlignmentCommentBlockNoCrash) { + // These inputs contain large multi-line comment blocks between + // parameter/localparam declarations. The formatter must not crash + // (SIGABRT). Output correctness is secondary; the formatter may + // fall back to preserving the original input when the partition + // structure prevents safe alignment. + const char *kInputs[] = { + "module m;\n" + "parameter int W = 8;\n" + "// Multi-line comment block\n" + "// that spans across\n" + "//\n" + "// several lines\n" + "// of explanatory text\n" + "//\n" + "// It contains enough\n" + "// lines to trigger\n" + "// the partition structure\n" + "// edge case where\n" + "// comment tokens are\n" + "// absorbed into the\n" + "// following parameter\n" + "// partition.\n" + "//\n" + "localparam int H = 2;\n" + "endmodule\n", + "package p;\n" + "parameter int X = 1;\n" + "// Long comment block\n" + "// with many lines\n" + "//\n" + "// of text\n" + "//\n" + "localparam int Y = 2;\n" + "endpackage\n", + }; + FormatStyle style; + style.column_limit = 40; + style.indentation_spaces = 2; + style.wrap_spaces = 4; + style.parameter_declaration_alignment = AlignmentPolicy::kAlign; + for (const char *input : kInputs) { + VLOG(1) << "code-to-format:\n" << input << "<EOF>"; + std::ostringstream stream; + const auto status = FormatVerilog(input, "<filename>", style, stream); + // The primary requirement is that the formatter does not crash + // (SIGABRT). Gtest will report failure if the process aborts. + // The partition structure may cause output format differences; + // the important thing is the formatter handled it gracefully. + } +} + +} // namespace +} // namespace formatter +} // namespace verilog
diff --git a/verible/verilog/formatting/formatter_class_package_test.cc b/verible/verilog/formatting/formatter_class_package_test.cc new file mode 100644 index 0000000..0c5e067 --- /dev/null +++ b/verible/verilog/formatting/formatter_class_package_test.cc
@@ -0,0 +1,974 @@ +// Copyright 2017-2026 The Verible Authors. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Test cases in this file should be *insensitive* to wrapping penalties. +// Penalty-sensitive tests belong in formatter-tuning_test.cc. + +#include "gtest/gtest.h" +#include "verible/verilog/formatting/formatter-test-utils.h" + +namespace verilog { +namespace formatter { +namespace { + +static constexpr FormatterTestCase kClassPackageFormatterTestCases[] = { + // interface test cases + {// two interface declarations + " interface if1 ; endinterface\t\t" + "interface if2; endinterface ", + "interface if1;\n" + "endinterface\n" + "interface if2;\n" + "endinterface\n"}, + {// two interface declarations, end labels + " interface if1 ; endinterface:if1\t\t" + "interface if2; endinterface : if2 ", + "interface if1;\n" + "endinterface : if1\n" + "interface if2;\n" + "endinterface : if2\n"}, + {// interface declaration with parameters + " interface if1#( parameter int W= 8 );endinterface\t\t", + "interface if1 #(\n" + " parameter int W = 8\n" + ");\n" + "endinterface\n"}, + {// interface declaration with ports (empty) + " interface if1()\n;endinterface\t\t", + "interface if1 ();\n" + "endinterface\n"}, + {// interface declaration with parameter comment only, empty ports + " interface if1#( \n" + "//param\n" + ")();endinterface\t\t", + "interface if1 #(\n" + " //param\n" + ") ();\n" + "endinterface\n"}, + {// interface declaration with parameter, empty ports + " interface if1#( parameter int W= 8 )();endinterface\t\t", + "interface if1 #(\n" + " parameter int W = 8\n" + ") ();\n" + "endinterface\n"}, + {// interface declaration with ports + " interface if1( input\tlogic z)\n;endinterface\t\t", + "interface if1 (\n" + " input logic z\n" + ");\n" + "endinterface\n"}, + {// interface declaration with multiple ports + " interface if1( input\tlogic z, output logic a)\n;endinterface\t\t", + "interface if1 (\n" + " input logic z,\n" // should be one-per-line, even it it fits + " output logic a\n" // aligned + ");\n" + "endinterface\n"}, + {// interface declaration with parameters and ports + " interface if1#( parameter int W= 8 )(input logic z);endinterface\t\t", + // doesn't fit on one line + "interface if1 #(\n" + " parameter int W = 8\n" + ") (\n" + " input logic z\n" + ");\n" + "endinterface\n"}, + { + // interface with modport declarations + "interface\tfoo_if ;" + "modport mp1\t( output a, input b);" + "modport\tmp2 (output c,input d );\t" + "endinterface", + "interface foo_if;\n" + " modport mp1(output a, input b);\n" + " modport mp2(output c, input d);\n" + "endinterface\n", + }, + { + // interface with long modport port names + "interface\tfoo_if ;" + "modport mp1\t( output a_long_output, input detailed_input_name);" + "endinterface", + "interface foo_if;\n" + " modport mp1(\n" + " output a_long_output,\n" + " input detailed_input_name\n" + " );\n" + "endinterface\n", + }, + { + // interface with modport declaration with multiple ports + "interface\tfoo_if ;" + "modport mp1\t( output a_long_output, input detailed_input_name);" + "endinterface", + "interface foo_if;\n" + " modport mp1(\n" + " output a_long_output,\n" + " input detailed_input_name\n" + " );\n" + "endinterface\n", + }, + { + // interface with modport TF port declaration + "interface\tfoo_if ;" + "modport mp1\t( output a, input b, import c);" + "endinterface", + "interface foo_if;\n" + " modport mp1(\n" + " output a,\n" + " input b,\n" + " import c\n" + " );\n" + "endinterface\n", + }, + { + // interface with complex modport ports list + "interface\tfoo_if ;" + "modport producer\t(input ready,\toutput data, valid, user," + " strobe, keep, last,\timport producer_reset, producer_tick);" + "modport consumer\t(input data, valid, user, strobe, keep, last," + " output ready,\timport consumer_reset, consumer_tick, consume);" + "endinterface", + "interface foo_if;\n" + " modport producer(\n" + " input ready,\n" + " output data, valid, user, strobe,\n" + " keep, last,\n" + " import producer_reset,\n" + " producer_tick\n" + " );\n" + " modport consumer(\n" + " input data, valid, user, strobe,\n" + " keep, last,\n" + " output ready,\n" + " import consumer_reset,\n" + " consumer_tick, consume\n" + " );\n" + "endinterface\n", + }, + { + // interface with modports and comments inside + "interface foo_if;\n" + " modport mp1(\n" + " // Our output\n" + " output a,\n" + " /* Inputs */\n" + " input b1, b_f /*last*/," + " import c\n" + " );\n" + "endinterface\n", + "interface foo_if;\n" + " modport mp1(\n" + " // Our output\n" + " output a,\n" + " /* Inputs */\n" + " input b1, b_f /*last*/,\n" + " import c\n" + " );\n" + "endinterface\n", + }, + + // class test cases + {"class action;int xyz;endclass : action\n", + "class action;\n" + " int xyz;\n" + "endclass : action\n"}, + {"class action extends mypkg :: inaction;endclass : action\n", + "class action extends mypkg::inaction;\n" // tests for spacing around :: + "endclass : action\n"}, + {"class c;function new;endfunction endclass", + "class c;\n" + " function new;\n" + " endfunction\n" + "endclass\n"}, + {"class c;function new ( );endfunction endclass", + "class c;\n" + " function new();\n" + " endfunction\n" + "endclass\n"}, + {"class c;function new ( string s );endfunction endclass", + "class c;\n" + " function new(string s);\n" + " endfunction\n" + "endclass\n"}, + {"class c;function new ( string s ,int i );endfunction endclass", + "class c;\n" + " function new(string s, int i);\n" + " endfunction\n" + "endclass\n"}, + {"class c;function void f;endfunction endclass", + "class c;\n" + " function void f;\n" + " endfunction\n" + "endclass\n"}, + {"class c;virtual function void f;endfunction endclass", + "class c;\n" + " virtual function void f;\n" + " endfunction\n" + "endclass\n"}, + {"class c;function int f ( );endfunction endclass", + "class c;\n" + " function int f();\n" + " endfunction\n" + "endclass\n"}, + {"class c;function int f ( int ii );endfunction endclass", + "class c;\n" + " function int f(int ii);\n" + " endfunction\n" + "endclass\n"}, + {"class c;function int f ( int ii ,bit bb );endfunction endclass", + "class c;\n" + " function int f(int ii, bit bb);\n" + " endfunction\n" + "endclass\n"}, + {"class c;task t ;endtask endclass", + "class c;\n" + " task t;\n" + " endtask\n" + "endclass\n"}, + {"class c;task t ( int ii ,bit bb );endtask endclass", + "class c;\n" + " task t(int ii, bit bb);\n" + " endtask\n" + "endclass\n"}, + {"class c; task automatic repeated_assigner;" + "repeat (count) y = w;" // single statement body + "endtask endclass", + "class c;\n" + " task automatic repeated_assigner;\n" + " repeat (count) y = w;\n" + " endtask\n" + "endclass\n"}, + {"class c; task automatic delayed_assigner;" + "# 100 y = w;" // delayed assignment + "endtask endclass", + "class c;\n" + " task automatic delayed_assigner;\n" + " #100 y = w;\n" + " endtask\n" + "endclass\n"}, + {"class c; task automatic labeled_assigner;" + "lbl : y = w;" // delayed assignment + "endtask endclass", + "class c;\n" + " task automatic labeled_assigner;\n" + " lbl : y = w;\n" // TODO(fangism): no space before ':' + " endtask\n" + "endclass\n"}, + // task with macro call + {"module m1;\ntask automatic t1();\n" + "t2(`R1(1)+ 8);endtask : t1\nendmodule", + "module m1;\n" + " task automatic t1();\n" + " t2(`R1(1) + 8);\n" + " endtask : t1\n" + "endmodule\n"}, + + // tasks with control statements + {"class c; task automatic waiter;" + "if (count == 0) begin #0; return;end " + "endtask endclass", + "class c;\n" + " task automatic waiter;\n" + " if (count == 0) begin\n" + " #0;\n" + " return;\n" + " end\n" + " endtask\n" + "endclass\n"}, + {"class c; task automatic heartbreaker;" + "if( c)if( d) break ;" + "endtask endclass", + "class c;\n" + " task automatic heartbreaker;\n" + " if (c) if (d) break;\n" + " endtask\n" + "endclass\n"}, + {"class c; task automatic waiter;" + "repeat (count) @(posedge clk);" + "endtask endclass", + "class c;\n" + " task automatic waiter;\n" + " repeat (count) @(posedge clk);\n" + " endtask\n" + "endclass\n"}, + {"class c; task automatic repeat_assigner;" + "repeat( r )\ny = w;" + "repeat( q )\ny = 1;" + "endtask endclass", + "class c;\n" + " task automatic repeat_assigner;\n" + " repeat (r) y = w;\n" + " repeat (q) y = 1;\n" + " endtask\n" + "endclass\n"}, + {"class c; task automatic event_control_assigner;" + "@ ( posedge clk )\ny = w;" + "@ ( negedge clk )\nz = w;" + "endtask endclass", + "class c;\n" + " task automatic event_control_assigner;\n" + " @(posedge clk) y = w;\n" + " @(negedge clk) z = w;\n" + " endtask\n" + "endclass\n"}, + { + // classes with surrrounding comments + // vertical spacing preserved + "\n// pre-c\n\n" + " class c ;\n" + "// c stuff\n" + "endclass\n" + " // pre-d\n" + "\n\nclass d ;\n" + " // d stuff\n" + "endclass\n" + "\n// the end\n", + "\n// pre-c\n\n" + "class c;\n" + " // c stuff\n" + "endclass\n" + "// pre-d\n\n\n" + "class d;\n" + " // d stuff\n" + "endclass\n\n" + "// the end\n", + }, + {// class with comments around task/function declarations + "class c; // c is for cookie\n" + " // f is for false\n" + "\tfunction f(integer size) ; endfunction\n" + " // t is for true\n" + "task t();endtask\n" + " // class is about to end\n" + "endclass", + "class c; // c is for cookie\n" + " // f is for false\n" + " function f(integer size);\n" + " endfunction\n" + " // t is for true\n" + " task t();\n" + " endtask\n" + " // class is about to end\n" + "endclass\n"}, + + // interface class test cases + {"interface class Foo;\nendclass\n", + "interface class Foo;\n" + "endclass\n"}, + {"interface class Foo ; endclass\n", + "interface class Foo;\n" + "endclass\n"}, + {"interface class Foo extends Bar , Baz ;\nendclass\n", + "interface class Foo extends Bar, Baz;\n" + "endclass\n"}, + {"interface class Foo;\n pure virtual task foo ( ) ; \nendclass\n", + "interface class Foo;\n" + " pure virtual task foo();\n" + "endclass\n"}, + + // class property alignment test cases + {"class c;\n" + "int foo ;\n" + "byte bar;\n" + "endclass : c\n", + "class c;\n" + " int foo;\n" + " byte bar;\n" + "endclass : c\n"}, + {"class c;\n" + "int foo;\n" + "const bit b;\n" + "endclass : c\n", + "class c;\n" + " int foo;\n" + " const bit b;\n" + "endclass : c\n"}, + {"class c;\n" + "rand logic l;\n" + "int foo;\n" + "endclass : c\n", + "class c;\n" + " rand logic l;\n" + " int foo;\n" + "endclass : c\n"}, + {"class c;\n" + "rand logic l;\n" + "const static int foo;\n" // more qualifiers + "endclass : c\n", + "class c;\n" + " rand logic l;\n" + " const static int foo;\n" + "endclass : c\n"}, + {"class c;\n" + "static local int foo;\n" + "const bit b;\n" + "endclass : c\n", + "class c;\n" + " static local int foo;\n" + " const bit b;\n" + "endclass : c\n"}, + {// example with queue + "class c;\n" + "int foo [$] ;\n" + "int foo_bar ;\n" + "endclass : c\n", + "class c;\n" + " int foo [$];\n" + " int foo_bar;\n" + "endclass : c\n"}, + {// subcolumns + "class cc;\n" + "rand bit [A-1:0] foo;\n" + "rand bit [A-1:0][2] bar;\n" + "int foobar[X+1:Y];\n" + "int baz[42];\n" + "rand bit qux[Z];\n" + "rand bit [1:0] quux[3:0];\n" + "rand bit [A:BB][42] quuz[7];\n" + "endclass\n", + "class cc;\n" + " rand bit [A-1: 0] foo;\n" + " rand bit [A-1: 0][ 2] bar;\n" + " int foobar[X+1:Y];\n" + " int baz [ 42];\n" + " rand bit qux [ Z];\n" + " rand bit [ 1: 0] quux [ 3:0];\n" + " rand bit [ A:BB][42] quuz [ 7];\n" + "endclass\n"}, + {"class cc;\n" + "int qux[2];\n" + "int quux[SIZE-1+SHIFT:SHIFT];\n" + "int quuz[SOME_CONSTANT];\n" + "endclass\n", + "class cc;\n" + " int qux [ 2];\n" + " int quux[SIZE-1+SHIFT:SHIFT];\n" + " int quuz[ SOME_CONSTANT];\n" + "endclass\n"}, + {// aligns over comments (ignored) + "class c;\n" + "// foo is...\n" + "int foo;\n" + "// b is...\n" + "const bit b;\n" + " // llama is...\n" + "logic llama;\n" + "endclass : c\n", + "class c;\n" + " // foo is...\n" + " int foo;\n" + " // b is...\n" + " const bit b;\n" + " // llama is...\n" + " logic llama;\n" + "endclass : c\n"}, + {// aligns over comments (ignored), even with blank lines + "class c;\n" + "// foo is...\n" + "int foo;\n" + "\n" + "// b is...\n" + "const bit b;\n" + "\n" + " // llama is...\n" + "logic llama;\n" + "endclass : c\n", + "class c;\n" + " // foo is...\n" + " int foo;\n" + "\n" + " // b is...\n" + " const bit b;\n" + "\n" + " // llama is...\n" + " logic llama;\n" + "endclass : c\n"}, + {"class c;\n" + "rand logic l;\n" + "int [1:0] foo;\n" + "endclass : c\n", + "class c;\n" + " rand logic l;\n" + " int [1:0] foo;\n" + "endclass : c\n"}, + {// non-data-declarations break up groups + "class c;\n" + "rand logic l;\n" + "int foo;\n" + "`uvm_bar_foo()\n" + "logic k;\n" + "rand int bar;\n" + "endclass : c\n", + "class c;\n" + " rand logic l;\n" + " int foo;\n" + " `uvm_bar_foo()\n" // separates alignment groups above/below + " logic k;\n" + " rand int bar;\n" + "endclass : c\n"}, + {// non-data-declarations break up groups + "class c;\n" + "logic k;\n" + "rand int bar;\n" + "function void f();\n" + "endfunction\n" + "rand logic l;\n" + "int foo;\n" + "endclass : c\n", + "class c;\n" + " logic k;\n" + " rand int bar;\n" + " function void f();\n" // function declaration breaks groups + " endfunction\n" + " rand logic l;\n" + " int foo;\n" + "endclass : c\n"}, + {// align single-value initializers at the '=' + "class c;\n" + "const logic foo=0;\n" + "const bit b=1;\n" + "endclass : c\n", + "class c;\n" + " const logic foo = 0;\n" + " const bit b = 1;\n" + "endclass : c\n"}, + {// align single-value initializers at the '=', over non-initialized + "class c;\n" + "const logic foo=0;\n" + "rand int iidrv;\n" + "const bit b=1;\n" + "endclass : c\n", + "class c;\n" + " const logic foo = 0;\n" + " rand int iidrv;\n" // no initializer, but align across this + " const bit b = 1;\n" + "endclass : c\n"}, + + // constraint test cases + { + "class foo; constraint c1_c{ } endclass", + "class foo;\n" + " constraint c1_c {}\n" + "endclass\n", + }, + { + "class foo; constraint c1_c{ } constraint c2_c{ } endclass", + "class foo;\n" + " constraint c1_c {}\n" + " constraint c2_c {}\n" + "endclass\n", + }, + { + "class foo; constraint c1_c{soft z==y;unique{baz};}endclass", + "class foo;\n" + " constraint c1_c {\n" + " soft z == y;\n" + " unique {baz};\n" + " }\n" + "endclass\n", + }, + { + "class foo; constraint c1_c{ //comment1\n" + "//comment2\n" + "//comment3\n" + "} endclass", + "class foo;\n" + " constraint c1_c { //comment1\n" + " //comment2\n" + " //comment3\n" + " }\n" + "endclass\n", + }, + + {"class foo;constraint c { " + "timer_enable dist { [ 8'h0 : 8'hfe ] :/ 90 , 8'hff :/ 10 }; " + "} endclass\n", + "class foo;\n" + " constraint c {\n" + " timer_enable dist {\n" + " [8'h0 : 8'hfe] :/ 90,\n" + " 8'hff :/ 10\n" // aligned + " };\n" + " }\n" + "endclass\n"}, + + { + "class Foo; constraint if_c { if (z) { soft x == y; } } endclass\n", + "class Foo;\n" + " constraint if_c {\n" + " if (z) {\n" + " soft x == y;\n" + " }\n" + " }\n" + "endclass\n", + }, + { + "class Foo; constraint if_c { if (z) {\n" + "//comment-a\n" + "soft x == y;\n" + "//comment-b\n" + "} } endclass\n", + "class Foo;\n" + " constraint if_c {\n" + " if (z) {\n" + " //comment-a\n" // properly indented + " soft x == y;\n" + " //comment-b\n" // properly indented + " }\n" + " }\n" + "endclass\n", + }, + { + "class c; " + "constraint c_has_config_error {" + "if (yyy) {zzzz == 1;} else {yyyyyyy == 0;}} " + "endclass", + "class c;\n" + " constraint c_has_config_error {\n" + " if (yyy) {\n" + " zzzz == 1;\n" + " } else {\n" + " yyyyyyy == 0;\n" + " }\n" + " }\n" + "endclass\n", + }, + // distributions: colon alignment + {"class c;\n" + "constraint co {\n" + "d dist {\n" + "[1:2]:/2,\n" + "[11:33]:/22,\n" + "[111:444]:/8,\n" + "[1:42]:/10,\n" + "[11:12]:/3\n" + "};\n" + "}\n" + "endclass\n", + "class c;\n" + " constraint co {\n" + " d dist {\n" + " [ 1 : 2] :/ 2,\n" + " [ 11 : 33] :/ 22,\n" + " [111 : 444] :/ 8,\n" + " [ 1 : 42] :/ 10,\n" + " [ 11 : 12] :/ 3\n" + " };\n" + " }\n" + "endclass\n"}, + // distributions: subcolumns + {"class foo;\n" + "constraint bar {\n" + "baz dist {\n" + "[1:2]:/2,\n" + "QUX[3:0]:/10,\n" + "[11:33]:/22,\n" + "ID_LONGER_THAN_RANGES:/3,\n" + "[111:QUUZ[Z]]:/8,\n" + "[X[4:0]:Y[8:Z-2]]:/8\n" + "};\n" + "}\n" + "endclass\n", + "class foo;\n" + " constraint bar {\n" + " baz dist {\n" + " [ 1 : 2] :/ 2,\n" + " QUX[3:0] :/ 10,\n" + " [ 11 : 33] :/ 22,\n" + " ID_LONGER_THAN_RANGES :/ 3,\n" + " [ 111 : QUUZ[Z]] :/ 8,\n" + " [X[4:0] : Y[8:Z-2]] :/ 8\n" + " };\n" + " }\n" + "endclass\n"}, + // class with empty parameter list + {"class foo #(); endclass", + "class foo #();\n" + "endclass\n"}, + // class with empty parameter list, with comment + {"class foo #( \n" + "// comment\n" + "); endclass", + "class foo #(\n" + " // comment\n" + ");\n" + "endclass\n"}, + // class with empty parameter list, extends + {"class foo #()extends bar ; endclass", + "class foo #() extends bar;\n" + "endclass\n"}, + // class extends from type with named parameters + {"class foo extends bar #(.N(N), .M(M)); endclass", + "class foo extends bar #(\n" + " .N(N),\n" + " .M(M)\n" + ");\n" + "endclass\n"}, + + // class with one parameter list + {"class foo #(type a = b); endclass", + "class foo #(\n" + " type a = b\n" + ");\n" + "endclass\n"}, + + // class with multiple paramter list + {"class foo #(type a = b, type c = d, type e = f); endclass", + "class foo #(\n" + " type a = b,\n" + " type c = d,\n" + " type e = f\n" + ");\n" + "endclass\n"}, + + // class with data members + {"class i_love_data ;const\ninteger sizer\t;endclass", + "class i_love_data;\n" + " const integer sizer;\n" + "endclass\n"}, + {"class i_love_data ;const\ninteger sizer=3\t;endclass", + "class i_love_data;\n" + " const integer sizer = 3;\n" + "endclass\n"}, + {"class i_love_data ;protected\nint count \t;endclass", + "class i_love_data;\n" + " protected int count;\n" + "endclass\n"}, + {"class i_love_data ;\t\nint counter\n ;int countess \t;endclass", + "class i_love_data;\n" + " int counter;\n" + " int countess;\n" + "endclass\n"}, + {"class i_love_params ;foo#( . bar) baz\t;endclass", + "class i_love_params;\n" + " foo #(.bar) baz;\n" + "endclass\n"}, + {"class i_love_params ;foo#( . bar ( bah )) baz\t;endclass", + "class i_love_params;\n" + " foo #(.bar(bah)) baz;\n" + "endclass\n"}, + {"class i_love_params ;foo#( . bar ( bah\n)," + ".\ncat( dog) ) baz\t;endclass", + "class i_love_params;\n" + " foo #(\n" + " .bar(bah),\n" + " .cat(dog)\n" + " ) baz;\n" + "endclass\n"}, + {"class i_love_params ;foo#( . bar) baz1,baz2\t;endclass", + "class i_love_params;\n" + " foo #(.bar) baz1, baz2;\n" + "endclass\n"}, + {"class i_love_params ;foo#( . bar) baz\t;baz#(.foo)bar;endclass", + "class i_love_params;\n" + " foo #(.bar) baz;\n" + " baz #(.foo) bar;\n" + "endclass\n"}, + {"class i_love_params // comment\n" + ";\n" + "foo#(\n" + ".foobar(quuuuux) // comment\n" + ", .cat(dog)\n" + ") baz // comment\n" + ";endclass\n", + "class i_love_params // comment\n" + ";\n" + " foo #(\n" + " .foobar(quuuuux) // comment\n" + " , .cat (dog)\n" + " ) baz // comment\n" + " ;\n" + "endclass\n"}, + + // typedef test cases + {"typedef enum logic\t{ A=0, B=1 }foo_t;", + "typedef enum logic {\n" + " A = 0,\n" + " B = 1\n" + "} foo_t;\n"}, + {"typedef enum uint8_t\t{ kA=8'b0, kB=8'b1 }foo_t;", + "typedef enum uint8_t {\n" // uint8_t is user-defined + " kA = 8'b0,\n" + " kB = 8'b1\n" + "} foo_t;\n"}, + {// With comments on same line as enum value + "typedef enum logic\t{ A=0, // foo\n" + "B,// bar\n" + "`ifndef DO_PANIC\n" + "C=42,// answer\n" + "`endif\n" + "D=3 // baz\n" + "}foo_t;", + "typedef enum logic {\n" + " A = 0, // foo\n" + " B, // bar\n" + "`ifndef DO_PANIC\n" + " C = 42, // answer\n" + "`endif\n" + " D = 3 // baz\n" + "} foo_t;\n"}, + {// with scalar dimensions + "typedef enum logic[2]\t{ A=0, B=1 }foo_t;", + "typedef enum logic [2] {\n" + " A = 0,\n" + " B = 1\n" + "} foo_t;\n"}, + {// with range dimensions + "typedef enum logic[1:0]\t{ A=0, B=1 }foo_t;", + "typedef enum logic [1:0] {\n" + " A = 0,\n" + " B = 1\n" + "} foo_t;\n"}, + {"typedef foo_pkg::baz_t#(.L(L), .W(W)) bar_t;\n", + "typedef foo_pkg::baz_t#(\n" + " .L(L),\n" + " .W(W)\n" + ") bar_t;\n"}, + // By default (class_parameter_space == false), no space before '#' + {"typedef dv_base_env_cov #(.CFG_T(tl_agent_env_cfg)) tl_agent_env_cov;\n", + "typedef dv_base_env_cov#(\n" + " .CFG_T(tl_agent_env_cfg)\n" + ") tl_agent_env_cov;\n"}, + {"typedef dv_base_env_cov#(.CFG_T(tl_agent_env_cfg)) tl_agent_env_cov;\n", + "typedef dv_base_env_cov#(\n" + " .CFG_T(tl_agent_env_cfg)\n" + ") tl_agent_env_cov;\n"}, + // single short parameter stays on one line + {"typedef my_class #(.P(P)) my_class_t;\n", + "typedef my_class#(.P(P)) my_class_t;\n"}, + + // let declarations each stay on their own line + {"module t;\n" + "let OFF = 4;\n" + "let UNIQUE = 32;\n" + "let PP(a) = 30 + a;\n" + "endmodule\n", + "module t;\n" + " let OFF = 4;\n" + " let UNIQUE = 32;\n" + " let PP(a) = 30 + a;\n" + "endmodule\n"}, + + // let declarations each stay on their own line + {"module t;\n" + "let OFF = 4;\n" + "let UNIQUE = 32;\n" + "let PP(a) = 30 + a;\n" + "endmodule\n", + "module t;\n" + " let OFF = 4;\n" + " let UNIQUE = 32;\n" + " let PP(a) = 30 + a;\n" + "endmodule\n"}, + + // package test cases + {"package fedex;localparam int www=3 ;endpackage : fedex\n", + "package fedex;\n" + " localparam int www = 3;\n" + "endpackage : fedex\n"}, + {"package typey ;" + "typedef enum int{ A=0, B=1 }foo_t;" + "typedef enum{ C=0, D=1 }bar_t;" + "endpackage:typey\n", + "package typey;\n" + " typedef enum int {\n" + " A = 0,\n" + " B = 1\n" + " } foo_t;\n" + " typedef enum {\n" + " C = 0,\n" + " D = 1\n" + " } bar_t;\n" + "endpackage : typey\n"}, + {// net type declarations + "package foo_pkg;" + "nettype shortreal\t\tfoo ;" + "nettype\nbar[1:0 ] baz with\tquux ;" + "endpackage", + "package foo_pkg;\n" + " nettype shortreal foo;\n" + " nettype bar [1:0] baz with quux;\n" + "endpackage\n"}, + {"package foo_pkg; \n" + "// function description.......\n" + "function automatic void bar();" + "endfunction " + "endpackage\n", + "package foo_pkg;\n" + " // function description.......\n" + " function automatic void bar();\n" + " endfunction\n" + "endpackage\n"}, + {"package foo_pkg; \n" + "// function description.......\n" + "function void bar(string name=\"x\" ) ;" + "endfunction " + "endpackage\n", + "package foo_pkg;\n" + " // function description.......\n" + " function void bar(string name = \"x\");\n" + " endfunction\n" + "endpackage\n"}, + {" package foo_pkg; \n" + "// class description.............\n" + "class classy;" + "endclass " + "endpackage\n", + "package foo_pkg;\n" + " // class description.............\n" + " class classy;\n" + " endclass\n" + "endpackage\n"}, + {"package\tfoo_pkg; \n" + "// class description.............\n" + "class classy; \n" + "// function description.......\n" + "function\nautomatic void bar( );" + "endfunction " + "endclass\t" + "endpackage\n", + "package foo_pkg;\n" + " // class description.............\n" + " class classy;\n" + " // function description.......\n" + " function automatic void bar();\n" + " endfunction\n" + " endclass\n" + "endpackage\n"}, + {"package fedex;\n" + " import \"asdf\" context function void bar(\n" + " input bit [2:1] aaaa, // EOL COMMENT\n" + " // another\n" + " input bit foo\n" + " );\n" + "endpackage\n", + "package fedex;\n" + " import \"asdf\" context\n" + " function void bar(\n" + " input\n bit [2:1] aaaa, // EOL COMMENT\n" + " // another\n" + " input bit foo\n" + " );\n" + "endpackage\n"}, + +}; + +TEST(FormatterEndToEndTest, ClassPackageFormatterTestCases) { + RunFormatterTestCases40(kClassPackageFormatterTestCases); +} + +} // namespace +} // namespace formatter +} // namespace verilog
diff --git a/verible/verilog/formatting/formatter_disable_test.cc b/verible/verilog/formatting/formatter_disable_test.cc new file mode 100644 index 0000000..b653063 --- /dev/null +++ b/verible/verilog/formatting/formatter_disable_test.cc
@@ -0,0 +1,5814 @@ +// Copyright 2017-2026 The Verible Authors. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Test cases in this file should be *insensitive* to wrapping penalties. +// Penalty-sensitive tests belong in formatter-tuning_test.cc. + +#include "gtest/gtest.h" +#include "verible/verilog/formatting/formatter-test-utils.h" + +namespace verilog { +namespace formatter { +namespace { + +static constexpr FormatterTestCase kDisableFormatterTestCases[] = { + // comment-controlled formatter disabling + {"// verilog_format: off\n" // disables whole file + " `include \t\t \"path/to/file.vh\"\n", + "// verilog_format: off\n" + " `include \t\t \"path/to/file.vh\"\n"}, // keeps bad spacing + {"/* verilog_format: off */\n" // disables whole file + " `include \t\t \"path/to/file.svh\" \n", + "/* verilog_format: off */\n" + " `include \t\t \"path/to/file.svh\" \n"}, // keeps bad spacing + {"// verilog_format: on\n" // already enabled, no effect + " `include \t \"path/to/file.svh\" \t\n", + "// verilog_format: on\n" + "`include \"path/to/file.svh\"\n"}, + {"// verilog_format: off\n" + "// verilog_format: on\n" // re-enable right away + " `include \t\t \"path/to/file.svh\" \n", + "// verilog_format: off\n" + "// verilog_format: on\n" + "`include \"path/to/file.svh\"\n"}, + {"/* aaa *//* bbb */\n" // not formatting controls + " `include \t\t \"path/to/file.svh\" \n", // should format + "/* aaa */ /* bbb */\n" // currently inserts 2 spaces + "`include \"path/to/file.svh\"\n"}, + {"/* verilog_format: off *//* verilog_format: on */\n" // re-enable + " `include \t\t \"path/to/file.svh\" \n", + // Note that this case normally wouldn't fit in 40 columns, + // but disabling formatting lets it overflow. + "/* verilog_format: off *//* verilog_format: on */\n" + "`include \"path/to/file.svh\"\n"}, + {"// verilog_format: off\n" + " `include \t\t \"path/to/fileA.svh\" // verilog_format: on\n" + " `include \t\t \"path/to/fileB.svh\" \n", + // re-enable formatting with comment trailing other tokens + "// verilog_format: off\n" + " `include \t\t \"path/to/fileA.svh\" // verilog_format: on\n" + "`include \"path/to/fileB.svh\"\n"}, + {" `include \t\t \"path/to/file1.vh\" \n" // format this + "// verilog_format: off\n" // start disabling + " `include \t\t \"path/to/file2.vh\" \n" + "\t\t\n" + " `include \t\t \"path/to/file3.vh\" \n" + "// verilog_format: on\n" // stop disabling + " `include \t\t \"path/to/file4.vh\" \n", // format this + "`include \"path/to/file1.vh\"\n" + "// verilog_format: off\n" // start disabling + " `include \t\t \"path/to/file2.vh\" \n" + "\t\t\n" + " `include \t\t \"path/to/file3.vh\" \n" + "// verilog_format: on\n" // stop disabling + "`include \"path/to/file4.vh\"\n"}, + {// disabling formatting on a module (to end of file) + "// verilog_format: off\n" + "module m;endmodule\n", + "// verilog_format: off\n" + "module m;endmodule\n"}, + {// disabling formatting on a module (to end of file) + "// verilog_format: off\n" + "module m;\n" + "unindented instantiation;\n" + "endmodule\n", + "// verilog_format: off\n" + "module m;\n" + "unindented instantiation;\n" + "endmodule\n"}, + {// disabling formatting inside a port declaration list disables alignment, + // but falls back to standard compaction. + "module align_off(\n" + "input w ,\n" + " // verilog_format: off\n" + "input wire [y:z] wwww,\n" + " // verilog_format: on\n" + "output reg xx\n" + ");\n" + "endmodule", + "module align_off (\n" + " input w ,\n" // preserved because group is partially disabled + " // verilog_format: off\n" + "input wire [y:z] wwww,\n" // not compacted + " // verilog_format: on\n" + " output reg xx\n" // preserved because group is partially disabled + ");\n" + "endmodule\n"}, + + {// multiple tokens with EOL comment + "module please; // don't break before the comment\n" + "endmodule\n", + "module please\n" + " ; // don't break before the comment\n" + "endmodule\n"}, + {// one token with EOL comment + "module please;\n" + "endmodule // don't break before the comment\n", + "module please;\n" + "endmodule // don't break before the comment\n"}, + { + // line with only an EOL comment + "module wild;\n" + "// a really long comment on its own line to be left alone\n" + "endmodule", + "module wild;\n" + " // a really long comment on its own line to be left alone\n" + "endmodule\n", + }, + { + // primitive declaration + "primitive primitive1(o, s, r);output o;reg o;input s;input r;table 1 " + "? :" + " ? : 0; ? 1 : 0 : -; endtable endprimitive", + "primitive primitive1(o, s, r);\n" + " output o;\n" + " reg o;\n" + " input s;\n" + " input r;\n" + " table\n" + " 1 ? : ? : 0;\n" + " ? 1 : 0 : -;\n" + " endtable\n" + "endprimitive\n", + }, + { + // one-input combinatorial UDP + "primitive primitive1 ( o,i ) ;output o;input i;" + " table 1 : 0 ; 0 : 1 ; endtable endprimitive", + "primitive primitive1(o, i);\n" + " output o;\n" + " input i;\n" + " table\n" + " 1 : 0;\n" + " 0 : 1;\n" + " endtable\n" + "endprimitive\n", + }, + { + // two-input combinatorial UDP + "primitive primitive2(o, s, r);output o;input s;input r;" + "table 1 ? : 0;? 1 : -; endtable endprimitive", + "primitive primitive2(o, s, r);\n" + " output o;\n" + " input s;\n" + " input r;\n" + " table\n" + " 1 ? : 0;\n" + " ? 1 : -;\n" + " endtable\n" + "endprimitive\n", + }, + { + // ten-input combinatorial UDP + "primitive comb10(o, i0, i1, i2, i3, i4, i5, i6, i7, i8, i9);" + "output o;input i0, i1, i2, i3, i4, i5, i6, i7, i8, i9;" + "table 0 ? ? ? ? ? ? ? ? 0 : 0;1 ? ? ? ? ? ? ? ? 0 : 1;" + "1 ? ? ? ? ? ? ? ? 1 : 1;0 ? ? ? ? ? ? ? ? 1 : 0;endtable endprimitive", + "primitive comb10(o, i0, i1, i2, i3, i4,\n" + " i5, i6, i7, i8, i9);\n" + " output o;\n" + " input i0, i1, i2, i3, i4, i5, i6, i7,\n" + " i8, i9;\n" + " table\n" + " 0 ? ? ? ? ? ? ? ? 0 : 0;\n" + " 1 ? ? ? ? ? ? ? ? 0 : 1;\n" + " 1 ? ? ? ? ? ? ? ? 1 : 1;\n" + " 0 ? ? ? ? ? ? ? ? 1 : 0;\n" + " endtable\n" + "endprimitive\n", + }, + { + // sequential level-sensitive UDP + "primitive level_seq(o, c, d);output o;reg o;" + " input c;input d;table\n" + "// C D state O\n" + "0 ? : ? : -; // No Change\n" + "? 0 : 0 : 0; // Unknown\n" + "endtable endprimitive", + "primitive level_seq(o, c, d);\n" + " output o;\n" + " reg o;\n" + " input c;\n" + " input d;\n" + " table\n" + " // C D state O\n" + " 0 ? : ? : -; // No Change\n" + " ? 0 : 0 : 0; // Unknown\n" + " endtable\n" + "endprimitive\n", + }, + { + // sequential edge-sensitive UDP + "primitive edge_seq(o, c, d);output o;reg o;input c;input d;" + "table (01) 0 : ? : 0;(01) 1 : ? : 1;(0?) 1 : 1 : 1;(0?) 0 : 0 : " + "0;\n" + "// ignore negative c\n" + "(?0) ? : ? : -;\n" + "// ignore changes on steady c\n" + "? (?\?) : ? : -; endtable endprimitive", + "primitive edge_seq(o, c, d);\n" + " output o;\n" + " reg o;\n" + " input c;\n" + " input d;\n" + " table\n" + " (01) 0 : ? : 0;\n" + " (01) 1 : ? : 1;\n" + " (0?) 1 : 1 : 1;\n" + " (0?) 0 : 0 : 0;\n" + " // ignore negative c\n" + " (?0) ? : ? : -;\n" + " // ignore changes on steady c\n" + " ? (?\?) : ? : -;\n" + " endtable\n" + "endprimitive\n", + }, + { + // mixed sequential UDP + "primitive mixed(o, clk, j, k, preset, clear);output o;reg o;" + "input c;input j, k;input preset, clear;table " + "? ?? 01:?:1 ; // preset logic\n" + "? ?? *1:1:1 ;? ?? 10:?:0 ; // clear logic\n" + "? ?? 1*:0:0 ;r 00 00:0:1 ; // normal\n" + "r 00 11:?:- ;r 01 11:?:0 ;r 10 11:?:1 ;r 11 11:0:1 ;" + "r 11 11:1:0 ;f ?? ??:?:- ;b *? ??:?:- ;" + " // j and k\n" + "b ?* ??:?:- ;endtable endprimitive\n", + "primitive mixed(o, clk, j, k, preset,\n" + " clear);\n" + " output o;\n" + " reg o;\n" + " input c;\n" + " input j, k;\n" + " input preset, clear;\n" + " table\n" + " ? ? ? 0 1 : ? : 1; // preset logic\n" + " ? ? ? * 1 : 1 : 1;\n" + " ? ? ? 1 0 : ? : 0; // clear logic\n" + " ? ? ? 1 * : 0 : 0;\n" + " r 0 0 0 0 : 0 : 1; // normal\n" + " r 0 0 1 1 : ? : -;\n" + " r 0 1 1 1 : ? : 0;\n" + " r 1 0 1 1 : ? : 1;\n" + " r 1 1 1 1 : 0 : 1;\n" + " r 1 1 1 1 : 1 : 0;\n" + " f ? ? ? ? : ? : -;\n" + " b * ? ? ? : ? : -; // j and k\n" + " b ? * ? ? : ? : -;\n" + " endtable\n" + "endprimitive\n", + }, + // un-lexed multiline macro arg token + { + " task S ; " + "`ppgJH3JoxhwyTmZ2dgPiuMQzpRAWiSs(" + "{xYtxuh6.FIMcVPEWfhtoI2FSe, xYtxuh6.ZVL5XASVGLYz32} == " + "SqRgavM[15:2];\n" + "JgQLBG == 4'h0;, \"foo\" )\n" + "endtask\n", + "task S;\n" + " `ppgJH3JoxhwyTmZ2dgPiuMQzpRAWiSs(\n" + " {xYtxuh6.FIMcVPEWfhtoI2FSe, xYtxuh6.ZVL5XASVGLYz32} == " + "SqRgavM[15:2];\n" + "JgQLBG == 4'h0;,\n" + " \"foo\")\n" + "endtask\n", + }, + + // between identifier and '(', no args + + {"// verilog_syntax: parse-as-module-body", + "// verilog_syntax: parse-as-module-body\n"}, + {"// verilog_syntax: parse-as-statements", + "// verilog_syntax: parse-as-statements\n"}, + {"// verilog_syntax: parse-as-class-body", + "// verilog_syntax: parse-as-class-body\n"}, + {"// verilog_syntax: parse-as-package-body", + "// verilog_syntax: parse-as-package-body\n"}, + {"// verilog_syntax: parse-as-library-map", + "// verilog_syntax: parse-as-library-map\n"}, + {"// verilog_syntax: does-not-exist-mode", + "// verilog_syntax: does-not-exist-mode\n"}, + {"// verilog_syntax: parse-as-module-body\n", + "// verilog_syntax: parse-as-module-body\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "// comment", + "// verilog_syntax: parse-as-module-body\n" + "// comment\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz /* c */ ();\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz /* c */ ();\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz /* c1 */ /* c2 */ ();\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz /* c1 */ /* c2 */ ();\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz /* c */\n" + "();\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz /* c */\n" + " ();\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz /* c1 */ /* c2 */\n" + "();\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz /* c1 */ /* c2 */\n" + " ();\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz // c\n" + "();\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz // c\n" + " ();\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz /* c1 */ // c2\n" + "();\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz /* c1 */ // c2\n" + " ();\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz\n" + "/* c */ ();\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz\n" + " /* c */ ();\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz\n" + "/* c1 */ /* c2 */ ();\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz\n" + " /* c1 */ /* c2 */ ();\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz\n" + "/* c */\n" + "();\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz\n" + " /* c */\n" + " ();\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz\n" + "/* c1 */ /* c2 */\n" + "();\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz\n" + " /* c1 */ /* c2 */\n" + " ();\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz\n" + "// c\n" + "();\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz\n" + " // c\n" + " ();\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz\n" + "/* c1 */ // c2\n" + "();\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz\n" + " /* c1 */ // c2\n" + " ();\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz\n" + "/* c1 */\n" + "/* c2 */\n" + "();\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz\n" + " /* c1 */\n" + " /* c2 */\n" + " ();\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz\n" + "// c1\n" + "// c2\n" + "();\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz\n" + " // c1\n" + " // c2\n" + " ();\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz /* c1 */\n" + "/* c2 */ ();\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz /* c1 */\n" + " /* c2 */ ();\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz // c1\n" + "/* c2 */ ();\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz // c1\n" + " /* c2 */ ();\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz /* c1 */\n" + "/* c2 */\n" + "/* c3 */ ();\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz /* c1 */\n" + " /* c2 */\n" + " /* c3 */ ();\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz /* c1 */\n" + "/* c2 */\n" + "();\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz /* c1 */\n" + " /* c2 */\n" + " ();\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz // c1\n" + "/* c2 */\n" + "();\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz // c1\n" + " /* c2 */\n" + " ();\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz /* c1 */\n" + "// c2\n" + "();\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz /* c1 */\n" + " // c2\n" + " ();\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz // c1\n" + "// c2\n" + "();\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz // c1\n" + " // c2\n" + " ();\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz /* c1 */\n" + "/* c2 */\n" + "/* c3 */\n" + "();\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz /* c1 */\n" + " /* c2 */\n" + " /* c3 */\n" + " ();\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz // c1\n" + "// c2\n" + "// c3\n" + "();\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz // c1\n" + " // c2\n" + " // c3\n" + " ();\n"}, + + // between identifier and '(', with arg + + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz /* c */ (arg);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz /* c */ (arg);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz /* c1 */ /* c2 */ (arg);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz /* c1 */ /* c2 */ (arg);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz /* c */\n" + "(arg);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz /* c */\n" + " (arg);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz /* c1 */ /* c2 */\n" + "(arg);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz /* c1 */ /* c2 */\n" + " (arg);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz // c\n" + "(arg);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz // c\n" + " (arg);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz /* c1 */ // c2\n" + "(arg);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz /* c1 */ // c2\n" + " (arg);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz\n" + "/* c */ (arg);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz\n" + " /* c */ (arg);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz\n" + "/* c1 */ /* c2 */ (arg);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz\n" + " /* c1 */ /* c2 */ (arg);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz\n" + "/* c */\n" + "(arg);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz\n" + " /* c */\n" + " (arg);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz\n" + "/* c1 */ /* c2 */\n" + "(arg);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz\n" + " /* c1 */ /* c2 */\n" + " (arg);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz\n" + "// c\n" + "(arg);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz\n" + " // c\n" + " (arg);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz\n" + "/* c1 */ // c2\n" + "(arg);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz\n" + " /* c1 */ // c2\n" + " (arg);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz\n" + "/* c1 */\n" + "/* c2 */\n" + "(arg);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz\n" + " /* c1 */\n" + " /* c2 */\n" + " (arg);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz\n" + "// c1\n" + "// c2\n" + "(arg);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz\n" + " // c1\n" + " // c2\n" + " (arg);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz /* c1 */\n" + "/* c2 */ (arg);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz /* c1 */\n" + " /* c2 */ (arg);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz // c1\n" + "/* c2 */ (arg);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz // c1\n" + " /* c2 */ (arg);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz /* c1 */\n" + "/* c2 */\n" + "/* c3 */ (arg);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz /* c1 */\n" + " /* c2 */\n" + " /* c3 */ (arg);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz /* c1 */\n" + "/* c2 */\n" + "(arg);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz /* c1 */\n" + " /* c2 */\n" + " (arg);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz // c1\n" + "/* c2 */\n" + "(arg);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz // c1\n" + " /* c2 */\n" + " (arg);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz /* c1 */\n" + "// c2\n" + "(arg);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz /* c1 */\n" + " // c2\n" + " (arg);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz // c1\n" + "// c2\n" + "(arg);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz // c1\n" + " // c2\n" + " (arg);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz /* c1 */\n" + "/* c2 */\n" + "/* c3 */\n" + "(arg);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz /* c1 */\n" + " /* c2 */\n" + " /* c3 */\n" + " (arg);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz // c1\n" + "// c2\n" + "// c3\n" + "(arg);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz // c1\n" + " // c2\n" + " // c3\n" + " (arg);\n"}, + + // after '(', no args + + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(/* c */);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz( /* c */);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(/* c1 */ /* c2 */);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz( /* c1 */ /* c2 */);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(/* c */\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz( /* c */\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(/* c1 */ /* c2 */\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz( /* c1 */ /* c2 */\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(// c\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz( // c\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(/* c1 */ // c2\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz( /* c1 */ // c2\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(\n" + "/* c */);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(\n" + "/* c */);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(\n" + "/* c1 */ /* c2 */);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(\n" + "/* c1 */ /* c2 */);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(\n" + "/* c */\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(\n" + " /* c */\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(\n" + "/* c1 */ /* c2 */\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(\n" + " /* c1 */ /* c2 */\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(\n" + "// c\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(\n" + " // c\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(\n" + "/* c1 */ // c2\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(\n" + " /* c1 */ // c2\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(\n" + "/* c1 */\n" + "/* c2 */\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(\n" + " /* c1 */\n" + " /* c2 */\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(\n" + "// c1\n" + "// c2\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(\n" + " // c1\n" + " // c2\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(/* c1 */\n" + "/* c2 */);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz( /* c1 */\n" + "/* c2 */);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(// c1\n" + "/* c2 */);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz( // c1\n" + "/* c2 */);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(/* c1 */\n" + "/* c2 */\n" + "/* c3 */);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz( /* c1 */\n" + " /* c2 */\n" + "/* c3 */);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(/* c1 */\n" + "/* c2 */\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz( /* c1 */\n" + " /* c2 */\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(// c1\n" + "/* c2 */\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz( // c1\n" + " /* c2 */\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(/* c1 */\n" + "// c2\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz( /* c1 */\n" + " // c2\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(// c1\n" + "// c2\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz( // c1\n" + " // c2\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(/* c1 */\n" + "/* c2 */\n" + "/* c3 */\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz( /* c1 */\n" + " /* c2 */\n" + " /* c3 */\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(// c1\n" + "// c2\n" + "// c3\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz( // c1\n" + " // c2\n" + " // c3\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(/* c */);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ( /* c */);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(/* c1 */ /* c2 */);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ( /* c1 */ /* c2 */);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(/* c */\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ( /* c */\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(/* c1 */ /* c2 */\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ( /* c1 */ /* c2 */\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(// c\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ( // c\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(/* c1 */ // c2\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ( /* c1 */ // c2\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(\n" + "/* c */);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(\n" + "/* c */);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(\n" + "/* c1 */ /* c2 */);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(\n" + "/* c1 */ /* c2 */);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(\n" + "/* c */\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(\n" + " /* c */\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(\n" + "/* c1 */ /* c2 */\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(\n" + " /* c1 */ /* c2 */\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(\n" + "// c\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(\n" + " // c\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(\n" + "/* c1 */ // c2\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(\n" + " /* c1 */ // c2\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(\n" + "/* c1 */\n" + "/* c2 */\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(\n" + " /* c1 */\n" + " /* c2 */\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(\n" + "// c1\n" + "// c2\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(\n" + " // c1\n" + " // c2\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(/* c1 */\n" + "/* c2 */);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ( /* c1 */\n" + "/* c2 */);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(// c1\n" + "/* c2 */);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ( // c1\n" + "/* c2 */);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(/* c1 */\n" + "/* c2 */\n" + "/* c3 */);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ( /* c1 */\n" + " /* c2 */\n" + "/* c3 */);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(/* c1 */\n" + "/* c2 */\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ( /* c1 */\n" + " /* c2 */\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(// c1\n" + "/* c2 */\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ( // c1\n" + " /* c2 */\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(/* c1 */\n" + "// c2\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ( /* c1 */\n" + " // c2\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(// c1\n" + "// c2\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ( // c1\n" + " // c2\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(/* c1 */\n" + "/* c2 */\n" + "/* c3 */\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ( /* c1 */\n" + " /* c2 */\n" + " /* c3 */\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(// c1\n" + "// c2\n" + "// c3\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ( // c1\n" + " // c2\n" + " // c3\n" + ");\n"}, + + // after '(', with arg + + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(/* c */arg);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz( /* c */ arg);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(/* c1 */ /* c2 */arg);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz( /* c1 */ /* c2 */ arg);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(/* c */\n" + "arg);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz( /* c */\n" + " arg);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(/* c1 */ /* c2 */\n" + "arg);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz( /* c1 */ /* c2 */\n" + " arg);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(// c\n" + "arg);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz( // c\n" + " arg);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(/* c1 */ // c2\n" + "arg);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz( /* c1 */ // c2\n" + " arg);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(\n" + "/* c */arg);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(\n" + " /* c */ arg);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(\n" + "/* c1 */ /* c2 */arg);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(\n" + " /* c1 */ /* c2 */ arg);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(\n" + "/* c */\n" + "arg);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(\n" + " /* c */\n" + " arg);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(\n" + "/* c1 */ /* c2 */\n" + "arg);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(\n" + " /* c1 */ /* c2 */\n" + " arg);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(\n" + "// c\n" + "arg);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(\n" + " // c\n" + " arg);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(\n" + "/* c1 */ // c2\n" + "arg);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(\n" + " /* c1 */ // c2\n" + " arg);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(\n" + "/* c1 */\n" + "/* c2 */\n" + "arg);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(\n" + " /* c1 */\n" + " /* c2 */\n" + " arg);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(\n" + "// c1\n" + "// c2\n" + "arg);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(\n" + " // c1\n" + " // c2\n" + " arg);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(/* c1 */\n" + "/* c2 */arg);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz( /* c1 */\n" + " /* c2 */ arg);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(// c1\n" + "/* c2 */arg);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz( // c1\n" + " /* c2 */ arg);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(/* c1 */\n" + "/* c2 */\n" + "/* c3 */arg);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz( /* c1 */\n" + " /* c2 */\n" + " /* c3 */ arg);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(/* c1 */\n" + "/* c2 */\n" + "arg);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz( /* c1 */\n" + " /* c2 */\n" + " arg);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(// c1\n" + "/* c2 */\n" + "arg);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz( // c1\n" + " /* c2 */\n" + " arg);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(/* c1 */\n" + "// c2\n" + "arg);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz( /* c1 */\n" + " // c2\n" + " arg);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(// c1\n" + "// c2\n" + "arg);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz( // c1\n" + " // c2\n" + " arg);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(/* c1 */\n" + "/* c2 */\n" + "/* c3 */\n" + "arg);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz( /* c1 */\n" + " /* c2 */\n" + " /* c3 */\n" + " arg);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(// c1\n" + "// c2\n" + "// c3\n" + "arg);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz( // c1\n" + " // c2\n" + " // c3\n" + " arg);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(/* c */arg);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ( /* c */ arg);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(/* c1 */ /* c2 */arg);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ( /* c1 */ /* c2 */ arg);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(/* c */\n" + "arg);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ( /* c */\n" + " arg);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(/* c1 */ /* c2 */\n" + "arg);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ( /* c1 */ /* c2 */\n" + " arg);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(// c\n" + "arg);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ( // c\n" + " arg);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(/* c1 */ // c2\n" + "arg);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ( /* c1 */ // c2\n" + " arg);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(\n" + "/* c */arg);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(\n" + " /* c */ arg);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(\n" + "/* c1 */ /* c2 */arg);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(\n" + " /* c1 */ /* c2 */ arg);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(\n" + "/* c */\n" + "arg);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(\n" + " /* c */\n" + " arg);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(\n" + "/* c1 */ /* c2 */\n" + "arg);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(\n" + " /* c1 */ /* c2 */\n" + " arg);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(\n" + "// c\n" + "arg);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(\n" + " // c\n" + " arg);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(\n" + "/* c1 */ // c2\n" + "arg);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(\n" + " /* c1 */ // c2\n" + " arg);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(\n" + "/* c1 */\n" + "/* c2 */\n" + "arg);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(\n" + " /* c1 */\n" + " /* c2 */\n" + " arg);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(\n" + "// c1\n" + "// c2\n" + "arg);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(\n" + " // c1\n" + " // c2\n" + " arg);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(/* c1 */\n" + "/* c2 */arg);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ( /* c1 */\n" + " /* c2 */ arg);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(// c1\n" + "/* c2 */arg);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ( // c1\n" + " /* c2 */ arg);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(/* c1 */\n" + "/* c2 */\n" + "/* c3 */arg);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ( /* c1 */\n" + " /* c2 */\n" + " /* c3 */ arg);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(/* c1 */\n" + "/* c2 */\n" + "arg);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ( /* c1 */\n" + " /* c2 */\n" + " arg);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(// c1\n" + "/* c2 */\n" + "arg);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ( // c1\n" + " /* c2 */\n" + " arg);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(/* c1 */\n" + "// c2\n" + "arg);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ( /* c1 */\n" + " // c2\n" + " arg);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(// c1\n" + "// c2\n" + "arg);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ( // c1\n" + " // c2\n" + " arg);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(/* c1 */\n" + "/* c2 */\n" + "/* c3 */\n" + "arg);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ( /* c1 */\n" + " /* c2 */\n" + " /* c3 */\n" + " arg);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(// c1\n" + "// c2\n" + "// c3\n" + "arg);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ( // c1\n" + " // c2\n" + " // c3\n" + " arg);\n"}, + + // after single arg + + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg/* c */);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg /* c */);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg/* c1 */ /* c2 */);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg /* c1 */ /* c2 */);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg/* c */\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg /* c */\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg/* c1 */ /* c2 */\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg /* c1 */ /* c2 */\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg// c\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg // c\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg/* c1 */ // c2\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg /* c1 */ // c2\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg\n" + "/* c */);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg\n" + "/* c */);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg\n" + "/* c1 */ /* c2 */);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg\n" + "/* c1 */ /* c2 */);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg\n" + "/* c */\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg\n" + " /* c */\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg\n" + "/* c1 */ /* c2 */\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg\n" + " /* c1 */ /* c2 */\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg\n" + "// c\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg\n" + " // c\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg\n" + "/* c1 */ // c2\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg\n" + " /* c1 */ // c2\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg\n" + "/* c1 */\n" + "/* c2 */\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg\n" + " /* c1 */\n" + " /* c2 */\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg\n" + "// c1\n" + "// c2\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg\n" + " // c1\n" + " // c2\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg/* c1 */\n" + "/* c2 */);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg /* c1 */\n" + "/* c2 */);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg// c1\n" + "/* c2 */);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg // c1\n" + "/* c2 */);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg/* c1 */\n" + "/* c2 */\n" + "/* c3 */);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg /* c1 */\n" + " /* c2 */\n" + "/* c3 */);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg/* c1 */\n" + "/* c2 */\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg /* c1 */\n" + " /* c2 */\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg// c1\n" + "/* c2 */\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg // c1\n" + " /* c2 */\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg/* c1 */\n" + "// c2\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg /* c1 */\n" + " // c2\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg// c1\n" + "// c2\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg // c1\n" + " // c2\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg/* c1 */\n" + "/* c2 */\n" + "/* c3 */\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg /* c1 */\n" + " /* c2 */\n" + " /* c3 */\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg// c1\n" + "// c2\n" + "// c3\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg // c1\n" + " // c2\n" + " // c3\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg/* c */);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg /* c */);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg/* c1 */ /* c2 */);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg /* c1 */ /* c2 */);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg/* c */\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg /* c */\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg/* c1 */ /* c2 */\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg /* c1 */ /* c2 */\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg// c\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg // c\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg/* c1 */ // c2\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg /* c1 */ // c2\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg\n" + "/* c */);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg\n" + "/* c */);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg\n" + "/* c1 */ /* c2 */);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg\n" + "/* c1 */ /* c2 */);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg\n" + "/* c */\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg\n" + " /* c */\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg\n" + "/* c1 */ /* c2 */\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg\n" + " /* c1 */ /* c2 */\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg\n" + "// c\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg\n" + " // c\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg\n" + "/* c1 */ // c2\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg\n" + " /* c1 */ // c2\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg\n" + "/* c1 */\n" + "/* c2 */\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg\n" + " /* c1 */\n" + " /* c2 */\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg\n" + "// c1\n" + "// c2\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg\n" + " // c1\n" + " // c2\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg/* c1 */\n" + "/* c2 */);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg /* c1 */\n" + "/* c2 */);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg// c1\n" + "/* c2 */);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg // c1\n" + "/* c2 */);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg/* c1 */\n" + "/* c2 */\n" + "/* c3 */);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg /* c1 */\n" + " /* c2 */\n" + "/* c3 */);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg/* c1 */\n" + "/* c2 */\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg /* c1 */\n" + " /* c2 */\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg// c1\n" + "/* c2 */\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg // c1\n" + " /* c2 */\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg/* c1 */\n" + "// c2\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg /* c1 */\n" + " // c2\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg// c1\n" + "// c2\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg // c1\n" + " // c2\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg/* c1 */\n" + "/* c2 */\n" + "/* c3 */\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg /* c1 */\n" + " /* c2 */\n" + " /* c3 */\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg// c1\n" + "// c2\n" + "// c3\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg // c1\n" + " // c2\n" + " // c3\n" + ");\n"}, + + // before colon + + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1/* c */, arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1 /* c */, arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1/* c1 */ /* c2 */, arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1 /* c1 */ /* c2 */,\n" + " arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1/* c */\n" + ", arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1 /* c */\n" + " , arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1/* c1 */ /* c2 */\n" + ", arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1 /* c1 */ /* c2 */\n" + " , arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1// c\n" + ", arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1 // c\n" + " , arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1/* c1 */ // c2\n" + ", arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1 /* c1 */ // c2\n" + " , arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1\n" + "/* c */, arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1\n" + " /* c */, arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1\n" + "/* c1 */ /* c2 */, arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1\n" + " /* c1 */ /* c2 */, arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1\n" + "/* c */\n" + ", arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1\n" + " /* c */\n" + " , arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1\n" + "/* c1 */ /* c2 */\n" + ", arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1\n" + " /* c1 */ /* c2 */\n" + " , arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1\n" + "// c\n" + ", arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1\n" + " // c\n" + " , arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1\n" + "/* c1 */ // c2\n" + ", arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1\n" + " /* c1 */ // c2\n" + " , arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1\n" + "/* c1 */\n" + "/* c2 */\n" + ", arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1\n" + " /* c1 */\n" + " /* c2 */\n" + " , arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1\n" + "// c1\n" + "// c2\n" + ", arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1\n" + " // c1\n" + " // c2\n" + " , arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1/* c1 */\n" + "/* c2 */, arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1 /* c1 */\n" + " /* c2 */, arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1// c1\n" + "/* c2 */, arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1 // c1\n" + " /* c2 */, arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1/* c1 */\n" + "/* c2 */\n" + "/* c3 */, arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1 /* c1 */\n" + " /* c2 */\n" + " /* c3 */, arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1/* c1 */\n" + "/* c2 */\n" + ", arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1 /* c1 */\n" + " /* c2 */\n" + " , arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1// c1\n" + "/* c2 */\n" + ", arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1 // c1\n" + " /* c2 */\n" + " , arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1/* c1 */\n" + "// c2\n" + ", arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1 /* c1 */\n" + " // c2\n" + " , arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1// c1\n" + "// c2\n" + ", arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1 // c1\n" + " // c2\n" + " , arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1/* c1 */\n" + "/* c2 */\n" + "/* c3 */\n" + ", arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1 /* c1 */\n" + " /* c2 */\n" + " /* c3 */\n" + " , arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1// c1\n" + "// c2\n" + "// c3\n" + ", arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1 // c1\n" + " // c2\n" + " // c3\n" + " , arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1/* c */, arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1 /* c */, arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1/* c1 */ /* c2 */, arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1 /* c1 */ /* c2 */,\n" + " arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1/* c */\n" + ", arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1 /* c */\n" + " , arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1/* c1 */ /* c2 */\n" + ", arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1 /* c1 */ /* c2 */\n" + " , arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1// c\n" + ", arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1 // c\n" + " , arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1/* c1 */ // c2\n" + ", arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1 /* c1 */ // c2\n" + " , arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1\n" + "/* c */, arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1\n" + " /* c */, arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1\n" + "/* c1 */ /* c2 */, arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1\n" + " /* c1 */ /* c2 */, arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1\n" + "/* c */\n" + ", arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1\n" + " /* c */\n" + " , arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1\n" + "/* c1 */ /* c2 */\n" + ", arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1\n" + " /* c1 */ /* c2 */\n" + " , arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1\n" + "// c\n" + ", arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1\n" + " // c\n" + " , arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1\n" + "/* c1 */ // c2\n" + ", arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1\n" + " /* c1 */ // c2\n" + " , arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1\n" + "/* c1 */\n" + "/* c2 */\n" + ", arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1\n" + " /* c1 */\n" + " /* c2 */\n" + " , arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1\n" + "// c1\n" + "// c2\n" + ", arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1\n" + " // c1\n" + " // c2\n" + " , arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1/* c1 */\n" + "/* c2 */, arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1 /* c1 */\n" + " /* c2 */, arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1// c1\n" + "/* c2 */, arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1 // c1\n" + " /* c2 */, arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1/* c1 */\n" + "/* c2 */\n" + "/* c3 */, arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1 /* c1 */\n" + " /* c2 */\n" + " /* c3 */, arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1/* c1 */\n" + "/* c2 */\n" + ", arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1 /* c1 */\n" + " /* c2 */\n" + " , arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1// c1\n" + "/* c2 */\n" + ", arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1 // c1\n" + " /* c2 */\n" + " , arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1/* c1 */\n" + "// c2\n" + ", arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1 /* c1 */\n" + " // c2\n" + " , arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1// c1\n" + "// c2\n" + ", arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1 // c1\n" + " // c2\n" + " , arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1/* c1 */\n" + "/* c2 */\n" + "/* c3 */\n" + ", arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1 /* c1 */\n" + " /* c2 */\n" + " /* c3 */\n" + " , arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1// c1\n" + "// c2\n" + "// c3\n" + ", arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1 // c1\n" + " // c2\n" + " // c3\n" + " , arg2);\n"}, + + // after colon + + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1,/* c */arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1, /* c */ arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1,/* c1 */ /* c2 */arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1, /* c1 */ /* c2 */\n" + " arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1,/* c */\n" + "arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1, /* c */\n" + " arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1,/* c1 */ /* c2 */\n" + "arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1, /* c1 */ /* c2 */\n" + " arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1,// c\n" + "arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1, // c\n" + " arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1,/* c1 */ // c2\n" + "arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1, /* c1 */ // c2\n" + " arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1,\n" + "/* c */arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1,\n" + " /* c */ arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1,\n" + "/* c1 */ /* c2 */arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1,\n" + " /* c1 */ /* c2 */ arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1,\n" + "/* c */\n" + "arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1,\n" + " /* c */\n" + " arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1,\n" + "/* c1 */ /* c2 */\n" + "arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1,\n" + " /* c1 */ /* c2 */\n" + " arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1,\n" + "// c\n" + "arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1,\n" + " // c\n" + " arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1,\n" + "/* c1 */ // c2\n" + "arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1,\n" + " /* c1 */ // c2\n" + " arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1,\n" + "/* c1 */\n" + "/* c2 */\n" + "arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1,\n" + " /* c1 */\n" + " /* c2 */\n" + " arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1,\n" + "// c1\n" + "// c2\n" + "arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1,\n" + " // c1\n" + " // c2\n" + " arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1,/* c1 */\n" + "/* c2 */arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1, /* c1 */\n" + " /* c2 */ arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1,// c1\n" + "/* c2 */arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1, // c1\n" + " /* c2 */ arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1,/* c1 */\n" + "/* c2 */\n" + "/* c3 */arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1, /* c1 */\n" + " /* c2 */\n" + " /* c3 */ arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1,/* c1 */\n" + "/* c2 */\n" + "arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1, /* c1 */\n" + " /* c2 */\n" + " arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1,// c1\n" + "/* c2 */\n" + "arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1, // c1\n" + " /* c2 */\n" + " arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1,/* c1 */\n" + "// c2\n" + "arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1, /* c1 */\n" + " // c2\n" + " arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1,// c1\n" + "// c2\n" + "arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1, // c1\n" + " // c2\n" + " arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1,/* c1 */\n" + "/* c2 */\n" + "/* c3 */\n" + "arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1, /* c1 */\n" + " /* c2 */\n" + " /* c3 */\n" + " arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1,// c1\n" + "// c2\n" + "// c3\n" + "arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1, // c1\n" + " // c2\n" + " // c3\n" + " arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1,/* c */arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1, /* c */ arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1,/* c1 */ /* c2 */arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1, /* c1 */ /* c2 */\n" + " arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1,/* c */\n" + "arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1, /* c */\n" + " arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1,/* c1 */ /* c2 */\n" + "arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1, /* c1 */ /* c2 */\n" + " arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1,// c\n" + "arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1, // c\n" + " arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1,/* c1 */ // c2\n" + "arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1, /* c1 */ // c2\n" + " arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1,\n" + "/* c */arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1,\n" + " /* c */ arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1,\n" + "/* c1 */ /* c2 */arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1,\n" + " /* c1 */ /* c2 */ arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1,\n" + "/* c */\n" + "arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1,\n" + " /* c */\n" + " arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1,\n" + "/* c1 */ /* c2 */\n" + "arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1,\n" + " /* c1 */ /* c2 */\n" + " arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1,\n" + "// c\n" + "arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1,\n" + " // c\n" + " arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1,\n" + "/* c1 */ // c2\n" + "arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1,\n" + " /* c1 */ // c2\n" + " arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1,\n" + "/* c1 */\n" + "/* c2 */\n" + "arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1,\n" + " /* c1 */\n" + " /* c2 */\n" + " arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1,\n" + "// c1\n" + "// c2\n" + "arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1,\n" + " // c1\n" + " // c2\n" + " arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1,/* c1 */\n" + "/* c2 */arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1, /* c1 */\n" + " /* c2 */ arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1,// c1\n" + "/* c2 */arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1, // c1\n" + " /* c2 */ arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1,/* c1 */\n" + "/* c2 */\n" + "/* c3 */arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1, /* c1 */\n" + " /* c2 */\n" + " /* c3 */ arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1,/* c1 */\n" + "/* c2 */\n" + "arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1, /* c1 */\n" + " /* c2 */\n" + " arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1,// c1\n" + "/* c2 */\n" + "arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1, // c1\n" + " /* c2 */\n" + " arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1,/* c1 */\n" + "// c2\n" + "arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1, /* c1 */\n" + " // c2\n" + " arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1,// c1\n" + "// c2\n" + "arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1, // c1\n" + " // c2\n" + " arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1,/* c1 */\n" + "/* c2 */\n" + "/* c3 */\n" + "arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1, /* c1 */\n" + " /* c2 */\n" + " /* c3 */\n" + " arg2);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1,// c1\n" + "// c2\n" + "// c3\n" + "arg2);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1, // c1\n" + " // c2\n" + " // c3\n" + " arg2);\n"}, + + // after last arg + + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1, arg2,/* c */);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1, arg2, /* c */);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1, arg2,/* c1 */ /* c2 */);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1,\n" + " arg2, /* c1 */ /* c2 */);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1, arg2,/* c */\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1, arg2, /* c */\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1, arg2,/* c1 */ /* c2 */\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1,\n" + " arg2, /* c1 */ /* c2 */\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1, arg2,// c\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1, arg2, // c\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1, arg2,/* c1 */ // c2\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1, arg2, /* c1 */ // c2\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1, arg2,\n" + "/* c */);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1, arg2,\n" + "/* c */);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1, arg2,\n" + "/* c1 */ /* c2 */);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1, arg2,\n" + "/* c1 */ /* c2 */);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1, arg2,\n" + "/* c */\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1, arg2,\n" + " /* c */\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1, arg2,\n" + "/* c1 */ /* c2 */\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1, arg2,\n" + " /* c1 */ /* c2 */\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1, arg2,\n" + "// c\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1, arg2,\n" + " // c\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1, arg2,\n" + "/* c1 */ // c2\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1, arg2,\n" + " /* c1 */ // c2\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1, arg2,\n" + "/* c1 */\n" + "/* c2 */\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1, arg2,\n" + " /* c1 */\n" + " /* c2 */\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1, arg2,\n" + "// c1\n" + "// c2\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1, arg2,\n" + " // c1\n" + " // c2\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1, arg2,/* c1 */\n" + "/* c2 */);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1, arg2, /* c1 */\n" + "/* c2 */);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1, arg2,// c1\n" + "/* c2 */);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1, arg2, // c1\n" + "/* c2 */);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1, arg2,/* c1 */\n" + "/* c2 */\n" + "/* c3 */);\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1, arg2, /* c1 */\n" + " /* c2 */\n" + "/* c3 */);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1, arg2,/* c1 */\n" + "/* c2 */\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1, arg2, /* c1 */\n" + " /* c2 */\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1, arg2,// c1\n" + "/* c2 */\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1, arg2, // c1\n" + " /* c2 */\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1, arg2,/* c1 */\n" + "// c2\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1, arg2, /* c1 */\n" + " // c2\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1, arg2,// c1\n" + "// c2\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1, arg2, // c1\n" + " // c2\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1, arg2,/* c1 */\n" + "/* c2 */\n" + "/* c3 */\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1, arg2, /* c1 */\n" + " /* c2 */\n" + " /* c3 */\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1, arg2,// c1\n" + "// c2\n" + "// c3\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg1, arg2, // c1\n" + " // c2\n" + " // c3\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1, arg2,/* c */);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1, arg2, /* c */);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1, arg2,/* c1 */ /* c2 */);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1,\n" + " arg2, /* c1 */ /* c2 */);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1, arg2,/* c */\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1, arg2, /* c */\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1, arg2,/* c1 */ /* c2 */\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1,\n" + " arg2, /* c1 */ /* c2 */\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1, arg2,// c\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1, arg2, // c\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1, arg2,/* c1 */ // c2\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1, arg2, /* c1 */ // c2\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1, arg2,\n" + "/* c */);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1, arg2,\n" + "/* c */);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1, arg2,\n" + "/* c1 */ /* c2 */);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1, arg2,\n" + "/* c1 */ /* c2 */);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1, arg2,\n" + "/* c */\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1, arg2,\n" + " /* c */\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1, arg2,\n" + "/* c1 */ /* c2 */\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1, arg2,\n" + " /* c1 */ /* c2 */\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1, arg2,\n" + "// c\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1, arg2,\n" + " // c\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1, arg2,\n" + "/* c1 */ // c2\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1, arg2,\n" + " /* c1 */ // c2\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1, arg2,\n" + "/* c1 */\n" + "/* c2 */\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1, arg2,\n" + " /* c1 */\n" + " /* c2 */\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1, arg2,\n" + "// c1\n" + "// c2\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1, arg2,\n" + " // c1\n" + " // c2\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1, arg2,/* c1 */\n" + "/* c2 */);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1, arg2, /* c1 */\n" + "/* c2 */);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1, arg2,// c1\n" + "/* c2 */);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1, arg2, // c1\n" + "/* c2 */);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1, arg2,/* c1 */\n" + "/* c2 */\n" + "/* c3 */);\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1, arg2, /* c1 */\n" + " /* c2 */\n" + "/* c3 */);\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1, arg2,/* c1 */\n" + "/* c2 */\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1, arg2, /* c1 */\n" + " /* c2 */\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1, arg2,// c1\n" + "/* c2 */\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1, arg2, // c1\n" + " /* c2 */\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1, arg2,/* c1 */\n" + "// c2\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1, arg2, /* c1 */\n" + " // c2\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1, arg2,// c1\n" + "// c2\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1, arg2, // c1\n" + " // c2\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1, arg2,/* c1 */\n" + "/* c2 */\n" + "/* c3 */\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1, arg2, /* c1 */\n" + " /* c2 */\n" + " /* c3 */\n" + ");\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1, arg2,// c1\n" + "// c2\n" + "// c3\n" + ");\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg1, arg2, // c1\n" + " // c2\n" + " // c3\n" + ");\n"}, + + // after ')', no args + + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz()/* c */;\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz() /* c */;\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz()/* c1 */ /* c2 */;\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz() /* c1 */ /* c2 */;\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz()/* c */\n" + ";\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz() /* c */\n" + ";\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz()/* c1 */ /* c2 */\n" + ";\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz() /* c1 */ /* c2 */\n" + ";\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz()// c\n" + ";\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz() // c\n" + ";\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz()/* c1 */ // c2\n" + ";\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz() /* c1 */ // c2\n" + ";\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz()\n" + "/* c */;\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz()\n" + "/* c */;\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz()\n" + "/* c1 */ /* c2 */;\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz()\n" + "/* c1 */ /* c2 */;\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz()\n" + "/* c */\n" + ";\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz()\n" + "/* c */\n" + ";\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz()\n" + "/* c1 */ /* c2 */\n" + ";\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz()\n" + "/* c1 */ /* c2 */\n" + ";\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz()\n" + "// c\n" + ";\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz()\n" + "// c\n" + ";\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz()\n" + "/* c1 */ // c2\n" + ";\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz()\n" + "/* c1 */ // c2\n" + ";\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz()\n" + "/* c1 */\n" + "/* c2 */\n" + ";\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz()\n" + "/* c1 */\n" + "/* c2 */\n" + ";\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz()\n" + "// c1\n" + "// c2\n" + ";\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz()\n" + "// c1\n" + "// c2\n" + ";\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz()/* c1 */\n" + "/* c2 */;\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz() /* c1 */\n" + "/* c2 */;\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz()// c1\n" + "/* c2 */;\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz() // c1\n" + "/* c2 */;\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz()/* c1 */\n" + "/* c2 */\n" + "/* c3 */;\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz() /* c1 */\n" + "/* c2 */\n" + "/* c3 */;\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz()/* c1 */\n" + "/* c2 */\n" + ";\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz() /* c1 */\n" + "/* c2 */\n" + ";\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz()// c1\n" + "/* c2 */\n" + ";\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz() // c1\n" + "/* c2 */\n" + ";\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz()/* c1 */\n" + "// c2\n" + ";\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz() /* c1 */\n" + "// c2\n" + ";\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz()// c1\n" + "// c2\n" + ";\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz() // c1\n" + "// c2\n" + ";\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz()/* c1 */\n" + "/* c2 */\n" + "/* c3 */\n" + ";\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz() /* c1 */\n" + "/* c2 */\n" + "/* c3 */\n" + ";\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz()// c1\n" + "// c2\n" + "// c3\n" + ";\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz() // c1\n" + "// c2\n" + "// c3\n" + ";\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ()/* c */;\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ() /* c */;\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ()/* c1 */ /* c2 */;\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ() /* c1 */ /* c2 */;\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ()/* c */\n" + ";\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ() /* c */\n" + ";\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ()/* c1 */ /* c2 */\n" + ";\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ() /* c1 */ /* c2 */\n" + ";\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ()// c\n" + ";\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ() // c\n" + ";\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ()/* c1 */ // c2\n" + ";\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ() /* c1 */ // c2\n" + ";\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ()\n" + "/* c */;\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ()\n" + "/* c */;\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ()\n" + "/* c1 */ /* c2 */;\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ()\n" + "/* c1 */ /* c2 */;\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ()\n" + "/* c */\n" + ";\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ()\n" + "/* c */\n" + ";\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ()\n" + "/* c1 */ /* c2 */\n" + ";\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ()\n" + "/* c1 */ /* c2 */\n" + ";\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ()\n" + "// c\n" + ";\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ()\n" + "// c\n" + ";\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ()\n" + "/* c1 */ // c2\n" + ";\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ()\n" + "/* c1 */ // c2\n" + ";\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ()\n" + "/* c1 */\n" + "/* c2 */\n" + ";\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ()\n" + "/* c1 */\n" + "/* c2 */\n" + ";\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ()\n" + "// c1\n" + "// c2\n" + ";\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ()\n" + "// c1\n" + "// c2\n" + ";\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ()/* c1 */\n" + "/* c2 */;\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ() /* c1 */\n" + "/* c2 */;\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ()// c1\n" + "/* c2 */;\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ() // c1\n" + "/* c2 */;\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ()/* c1 */\n" + "/* c2 */\n" + "/* c3 */;\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ() /* c1 */\n" + "/* c2 */\n" + "/* c3 */;\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ()/* c1 */\n" + "/* c2 */\n" + ";\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ() /* c1 */\n" + "/* c2 */\n" + ";\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ()// c1\n" + "/* c2 */\n" + ";\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ() // c1\n" + "/* c2 */\n" + ";\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ()/* c1 */\n" + "// c2\n" + ";\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ() /* c1 */\n" + "// c2\n" + ";\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ()// c1\n" + "// c2\n" + ";\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ() // c1\n" + "// c2\n" + ";\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ()/* c1 */\n" + "/* c2 */\n" + "/* c3 */\n" + ";\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ() /* c1 */\n" + "/* c2 */\n" + "/* c3 */\n" + ";\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ()// c1\n" + "// c2\n" + "// c3\n" + ";\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ() // c1\n" + "// c2\n" + "// c3\n" + ";\n"}, + + // after ')', with arg + + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg)/* c */;\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg) /* c */;\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg)/* c1 */ /* c2 */;\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg) /* c1 */ /* c2 */;\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg)/* c */\n" + ";\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg) /* c */\n" + ";\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg)/* c1 */ /* c2 */\n" + ";\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg) /* c1 */ /* c2 */\n" + ";\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg)// c\n" + ";\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg) // c\n" + ";\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg)/* c1 */ // c2\n" + ";\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg) /* c1 */ // c2\n" + ";\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg)\n" + "/* c */;\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg)\n" + "/* c */;\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg)\n" + "/* c1 */ /* c2 */;\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg)\n" + "/* c1 */ /* c2 */;\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg)\n" + "/* c */\n" + ";\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg)\n" + "/* c */\n" + ";\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg)\n" + "/* c1 */ /* c2 */\n" + ";\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg)\n" + "/* c1 */ /* c2 */\n" + ";\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg)\n" + "// c\n" + ";\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg) // c\n" + ";\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg)\n" + "/* c1 */ // c2\n" + ";\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg)\n" + "/* c1 */ // c2\n" + ";\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg)\n" + "/* c1 */\n" + "/* c2 */\n" + ";\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg)\n" + "/* c1 */\n" + "/* c2 */\n" + ";\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg)\n" + "// c1\n" + "// c2\n" + ";\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg)\n" + "// c1\n" + "// c2\n" + ";\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg)/* c1 */\n" + "/* c2 */;\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg) /* c1 */\n" + "/* c2 */;\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg)// c1\n" + "/* c2 */;\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg) // c1\n" + "/* c2 */;\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg)/* c1 */\n" + "/* c2 */\n" + "/* c3 */;\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg) /* c1 */\n" + "/* c2 */\n" + "/* c3 */;\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg)/* c1 */\n" + "/* c2 */\n" + ";\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg) /* c1 */\n" + "/* c2 */\n" + ";\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg)// c1\n" + "/* c2 */\n" + ";\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg) // c1\n" + "/* c2 */\n" + ";\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg)/* c1 */\n" + "// c2\n" + ";\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg) /* c1 */\n" + "// c2\n" + ";\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg)// c1\n" + "// c2\n" + ";\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg) // c1\n" + "// c2\n" + ";\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg)/* c1 */\n" + "/* c2 */\n" + "/* c3 */\n" + ";\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg) /* c1 */\n" + "/* c2 */\n" + "/* c3 */\n" + ";\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg)// c1\n" + "// c2\n" + "// c3\n" + ";\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg) // c1\n" + "// c2\n" + "// c3\n" + ";\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg)/* c */;\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg) /* c */;\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg)/* c1 */ /* c2 */;\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg) /* c1 */ /* c2 */;\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg)/* c */\n" + ";\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg) /* c */\n" + ";\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg)/* c1 */ /* c2 */\n" + ";\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg) /* c1 */ /* c2 */\n" + ";\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg)// c\n" + ";\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg) // c\n" + ";\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg)/* c1 */ // c2\n" + ";\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg) /* c1 */ // c2\n" + ";\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg)\n" + "/* c */;\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg)\n" + "/* c */;\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg)\n" + "/* c1 */ /* c2 */;\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg)\n" + "/* c1 */ /* c2 */;\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg)\n" + "/* c */\n" + ";\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg)\n" + "/* c */\n" + ";\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg)\n" + "/* c1 */ /* c2 */\n" + ";\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg)\n" + "/* c1 */ /* c2 */\n" + ";\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg)\n" + "// c\n" + ";\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg)\n" + "// c\n" + ";\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg)\n" + "/* c1 */ // c2\n" + ";\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg)\n" + "/* c1 */ // c2\n" + ";\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg)\n" + "/* c1 */\n" + "/* c2 */\n" + ";\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg)\n" + "/* c1 */\n" + "/* c2 */\n" + ";\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg)\n" + "// c1\n" + "// c2\n" + ";\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg)\n" + "// c1\n" + "// c2\n" + ";\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg)/* c1 */\n" + "/* c2 */;\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg) /* c1 */\n" + "/* c2 */;\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg)// c1\n" + "/* c2 */;\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg) // c1\n" + "/* c2 */;\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg)/* c1 */\n" + "/* c2 */\n" + "/* c3 */;\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg) /* c1 */\n" + "/* c2 */\n" + "/* c3 */;\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg)/* c1 */\n" + "/* c2 */\n" + ";\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg) /* c1 */\n" + "/* c2 */\n" + ";\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg)// c1\n" + "/* c2 */\n" + ";\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg) // c1\n" + "/* c2 */\n" + ";\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg)/* c1 */\n" + "// c2\n" + ";\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg) /* c1 */\n" + "// c2\n" + ";\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg)// c1\n" + "// c2\n" + ";\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg) // c1\n" + "// c2\n" + ";\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg)/* c1 */\n" + "/* c2 */\n" + "/* c3 */\n" + ";\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg) /* c1 */\n" + "/* c2 */\n" + "/* c3 */\n" + ";\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg)// c1\n" + "// c2\n" + "// c3\n" + ";\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg) // c1\n" + "// c2\n" + "// c3\n" + ";\n"}, + + // after ';', no args + + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz();/* c */\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(); /* c */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz();/* c1 */ /* c2 */\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(); /* c1 */ /* c2 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz();/* c */\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(); /* c */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz();/* c1 */ /* c2 */\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(); /* c1 */ /* c2 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz();// c\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(); // c\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz();/* c1 */ // c2\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(); /* c1 */ // c2\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz();\n" + "/* c */\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz();\n" + "/* c */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz();\n" + "/* c1 */ /* c2 */\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz();\n" + "/* c1 */ /* c2 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz();\n" + "/* c */\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz();\n" + "/* c */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz();\n" + "/* c1 */ /* c2 */\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz();\n" + "/* c1 */ /* c2 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz();\n" + "// c\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz();\n" + "// c\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz();\n" + "/* c1 */ // c2\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz();\n" + "/* c1 */ // c2\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz();\n" + "/* c1 */\n" + "/* c2 */\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz();\n" + "/* c1 */\n" + "/* c2 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz();\n" + "// c1\n" + "// c2\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz();\n" + "// c1\n" + "// c2\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz();/* c1 */\n" + "/* c2 */\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(); /* c1 */\n" + "/* c2 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz();// c1\n" + "/* c2 */\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(); // c1\n" + "/* c2 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz();/* c1 */\n" + "/* c2 */\n" + "/* c3 */\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(); /* c1 */\n" + "/* c2 */\n" + "/* c3 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz();/* c1 */\n" + "/* c2 */\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(); /* c1 */\n" + "/* c2 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz();// c1 c2 */\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(); // c1 c2 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz();/* c1 */\n" + "// c2\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(); /* c1 */\n" + "// c2\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz();// c1\n" + "// c2\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(); // c1\n" + "// c2\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz();/* c1 */\n" + "/* c2 */\n" + "/* c3 */\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(); /* c1 */\n" + "/* c2 */\n" + "/* c3 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz();// c1\n" + "// c2\n" + "// c3\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(); // c1\n" + "// c2\n" + "// c3\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ();/* c */\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(); /* c */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ();/* c1 */ /* c2 */\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(); /* c1 */ /* c2 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ();/* c */\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(); /* c */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ();/* c1 */ /* c2 */\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(); /* c1 */ /* c2 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ();// c\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(); // c\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ();/* c1 */ // c2\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(); /* c1 */ // c2\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ();\n" + "/* c */\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ();\n" + "/* c */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ();\n" + "/* c1 */ /* c2 */\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ();\n" + "/* c1 */ /* c2 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ();\n" + "/* c */\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ();\n" + "/* c */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ();\n" + "/* c1 */ /* c2 */\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ();\n" + "/* c1 */ /* c2 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ();\n" + "// c\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ();\n" + "// c\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ();\n" + "/* c1 */ // c2\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ();\n" + "/* c1 */ // c2\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ();\n" + "/* c1 */\n" + "/* c2 */\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ();\n" + "/* c1 */\n" + "/* c2 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ();\n" + "// c1\n" + "// c2\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ();\n" + "// c1\n" + "// c2\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ();/* c1 */\n" + "/* c2 */\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(); /* c1 */\n" + "/* c2 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ();// c1\n" + "/* c2 */\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(); // c1\n" + "/* c2 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ();/* c1 */\n" + "/* c2 */\n" + "/* c3 */\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(); /* c1 */\n" + "/* c2 */\n" + "/* c3 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ();/* c1 */\n" + "/* c2 */\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(); /* c1 */\n" + "/* c2 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ();// c1\n" + "/* c2 */\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(); // c1\n" + "/* c2 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ();/* c1 */\n" + "// c2\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(); /* c1 */\n" + "// c2\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ();// c1\n" + "// c2\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(); // c1\n" + "// c2\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ();/* c1 */\n" + "/* c2 */\n" + "/* c3 */\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(); /* c1 */\n" + "/* c2 */\n" + "/* c3 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ();// c1\n" + "// c2\n" + "// c3\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(); // c1\n" + "// c2\n" + "// c3\n"}, + + // after ';', with arg + + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg);/* c */\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg); /* c */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg);/* c1 */ /* c2 */\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg); /* c1 */ /* c2 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg);/* c */\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg); /* c */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg);/* c1 */ /* c2 */\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg); /* c1 */ /* c2 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg);// c\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg); // c\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg);/* c1 */ // c2\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg); /* c1 */ // c2\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg);\n" + "/* c */\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg);\n" + "/* c */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg);\n" + "/* c1 */ /* c2 */\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg);\n" + "/* c1 */ /* c2 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg);\n" + "/* c */\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg);\n" + "/* c */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg);\n" + "/* c1 */ /* c2 */\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg);\n" + "/* c1 */ /* c2 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg);\n" + "// c\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg);\n" + "// c\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg);\n" + "/* c1 */ // c2\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg);\n" + "/* c1 */ // c2\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg);\n" + "/* c1 */\n" + "/* c2 */\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg);\n" + "/* c1 */\n" + "/* c2 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg);\n" + "// c1\n" + "// c2\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg);\n" + "// c1\n" + "// c2\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg);/* c1 */\n" + "/* c2 */\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg); /* c1 */\n" + "/* c2 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg);// c1\n" + "/* c2 */\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg); // c1\n" + "/* c2 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg);/* c1 */\n" + "/* c2 */\n" + "/* c3 */\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg); /* c1 */\n" + "/* c2 */\n" + "/* c3 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg);/* c1 */\n" + "/* c2 */\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg); /* c1 */\n" + "/* c2 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg);// c1 c2 */\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg); // c1 c2 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg);/* c1 */\n" + "// c2\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg); /* c1 */\n" + "// c2\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg);// c1\n" + "// c2\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg); // c1\n" + "// c2\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg);/* c1 */\n" + "/* c2 */\n" + "/* c3 */\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg); /* c1 */\n" + "/* c2 */\n" + "/* c3 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg);// c1\n" + "// c2\n" + "// c3\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz(arg); // c1\n" + "// c2\n" + "// c3\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg);/* c */\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg); /* c */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg);/* c1 */ /* c2 */\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg); /* c1 */ /* c2 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg);/* c */\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg); /* c */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg);/* c1 */ /* c2 */\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg); /* c1 */ /* c2 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg);// c\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg); // c\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg);/* c1 */ // c2\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg); /* c1 */ // c2\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg);\n" + "/* c */\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg);\n" + "/* c */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg);\n" + "/* c1 */ /* c2 */\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg);\n" + "/* c1 */ /* c2 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg);\n" + "/* c */\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg);\n" + "/* c */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg);\n" + "/* c1 */ /* c2 */\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg);\n" + "/* c1 */ /* c2 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg);\n" + "// c\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg);\n" + "// c\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg);\n" + "/* c1 */ // c2\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg);\n" + "/* c1 */ // c2\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg);\n" + "/* c1 */\n" + "/* c2 */\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg);\n" + "/* c1 */\n" + "/* c2 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg);\n" + "// c1\n" + "// c2\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg);\n" + "// c1\n" + "// c2\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg);/* c1 */\n" + "/* c2 */\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg); /* c1 */\n" + "/* c2 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg);// c1\n" + "/* c2 */\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg); // c1\n" + "/* c2 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg);/* c1 */\n" + "/* c2 */\n" + "/* c3 */\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg); /* c1 */\n" + "/* c2 */\n" + "/* c3 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg);/* c1 */\n" + "/* c2 */\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg); /* c1 */\n" + "/* c2 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg);// c1\n" + "/* c2 */\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg); // c1\n" + "/* c2 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg);/* c1 */\n" + "// c2\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg); /* c1 */\n" + "// c2\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg);// c1\n" + "// c2\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg); // c1\n" + "// c2\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg);/* c1 */\n" + "/* c2 */\n" + "/* c3 */\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg); /* c1 */\n" + "/* c2 */\n" + "/* c3 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg);// c1\n" + "// c2\n" + "// c3\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(arg); // c1\n" + "// c2\n" + "// c3\n"}, + + // everywhere, no args + + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz/* c */(/* c */)/* c */;/* c */\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz /* c */\n" + " ( /* c */) /* c */; /* c */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz/* c1 */ /* c2 */(/* c1 */ /* c2 */)/* c1 */ /* c2 */;/* c1 */ " + "/* c2 */\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz /* c1 */ /* c2 */\n" + " ( /* c1 */ /* c2 */) /* c1 */ /* c2 */; /* c1 */ /* c2 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz/* c */\n" + "(/* c */\n" + ")/* c */\n" + ";/* c */\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz /* c */\n" + " ( /* c */\n" + " ) /* c */\n" + "; /* c */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz/* c1 */ /* c2 */\n" + "(/* c1 */ /* c2 */\n" + ")/* c1 */ /* c2 */\n" + ";/* c1 */ /* c2 */\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz /* c1 */ /* c2 */\n" + " ( /* c1 */ /* c2 */\n" + " ) /* c1 */ /* c2 */\n" + "; /* c1 */ /* c2 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz// c\n" + "(// c\n" + ")// c\n" + ";// c\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz // c\n" + " ( // c\n" + " ) // c\n" + "; // c\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz/* c1 */ // c2\n" + "(/* c1 */ // c2\n" + ")/* c1 */ // c2\n" + ";/* c1 */ // c2\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz /* c1 */ // c2\n" + " ( /* c1 */ // c2\n" + " ) /* c1 */ // c2\n" + "; /* c1 */ // c2\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz\n" + "/* c */(\n" + "/* c */)\n" + "/* c */;\n" + "/* c */\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz\n" + " /* c */ (\n" + " /* c */)\n" + "/* c */;\n" + "/* c */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz\n" + "/* c1 */ /* c2 */(\n" + "/* c1 */ /* c2 */)\n" + "/* c1 */ /* c2 */;\n" + "/* c1 */ /* c2 */\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz\n" + " /* c1 */ /* c2 */ (\n" + " /* c1 */ /* c2 */)\n" + "/* c1 */ /* c2 */;\n" + "/* c1 */ /* c2 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz\n" + "/* c */\n" + "(\n" + "/* c */\n" + ")\n" + "/* c */\n" + ";\n" + "/* c */\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz\n" + " /* c */\n" + " (\n" + " /* c */\n" + " )\n" + "/* c */\n" + ";\n" + "/* c */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz\n" + "/* c1 */ /* c2 */\n" + "(\n" + "/* c1 */ /* c2 */\n" + ")\n" + "/* c1 */ /* c2 */\n" + ";\n" + "/* c1 */ /* c2 */\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz\n" + " /* c1 */ /* c2 */\n" + " (\n" + " /* c1 */ /* c2 */\n" + " )\n" + "/* c1 */ /* c2 */\n" + ";\n" + "/* c1 */ /* c2 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz\n" + "// c\n" + "(\n" + "// c\n" + ")\n" + "// c\n" + ";\n" + "// c\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz\n" + " // c\n" + " (\n" + " // c\n" + " )\n" + "// c\n" + ";\n" + "// c\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz\n" + "/* c1 */ // c2\n" + "(\n" + "/* c1 */ // c2\n" + ")\n" + "/* c1 */ // c2\n" + ";\n" + "/* c1 */ // c2\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz\n" + " /* c1 */ // c2\n" + " (\n" + " /* c1 */ // c2\n" + " )\n" + "/* c1 */ // c2\n" + ";\n" + "/* c1 */ // c2\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz\n" + "/* c1 */\n" + "/* c2 */\n" + "(\n" + "/* c1 */\n" + "/* c2 */\n" + ")\n" + "/* c1 */\n" + "/* c2 */\n" + ";\n" + "/* c1 */\n" + "/* c2 */\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz\n" + " /* c1 */\n" + " /* c2 */\n" + " (\n" + " /* c1 */\n" + " /* c2 */\n" + " )\n" + "/* c1 */\n" + "/* c2 */\n" + ";\n" + "/* c1 */\n" + "/* c2 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz\n" + "// c1\n" + "// c2\n" + "(\n" + "// c1\n" + "// c2\n" + ")\n" + "// c1\n" + "// c2\n" + ";\n" + "// c1\n" + "// c2\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz\n" + " // c1\n" + " // c2\n" + " (\n" + " // c1\n" + " // c2\n" + " )\n" + "// c1\n" + "// c2\n" + ";\n" + "// c1\n" + "// c2\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz/* c1 */\n" + "/* c2 */(/* c1 */\n" + "/* c2 */)/* c1 */\n" + "/* c2 */;/* c1 */\n" + "/* c2 */\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz /* c1 */\n" + " /* c2 */ ( /* c1 */\n" + " /* c2 */) /* c1 */\n" + "/* c2 */; /* c1 */\n" + "/* c2 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz// c1\n" + "/* c2 */(// c1\n" + "/* c2 */)// c1\n" + "/* c2 */;// c1\n" + "/* c2 */\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz // c1\n" + " /* c2 */ ( // c1\n" + " /* c2 */) // c1\n" + "/* c2 */; // c1\n" + "/* c2 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz/* c1 */\n" + "/* c2 */\n" + "/* c3 */(/* c1 */\n" + "/* c2 */\n" + "/* c3 */)/* c1 */\n" + "/* c2 */\n" + "/* c3 */;/* c1 */\n" + "/* c2 */\n" + "/* c3 */\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz /* c1 */\n" + " /* c2 */\n" + " /* c3 */ ( /* c1 */\n" + " /* c2 */\n" + " /* c3 */) /* c1 */\n" + "/* c2 */\n" + "/* c3 */; /* c1 */\n" + "/* c2 */\n" + "/* c3 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz/* c1 */\n" + "/* c2 */\n" + "(/* c1 */\n" + "/* c2 */\n" + ")/* c1 */\n" + "/* c2 */\n" + ";/* c1 */\n" + "/* c2 */\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz /* c1 */\n" + " /* c2 */\n" + " ( /* c1 */\n" + " /* c2 */\n" + " ) /* c1 */\n" + "/* c2 */\n" + "; /* c1 */\n" + "/* c2 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz// c1\n" + "/* c2 */\n" + "(// c1\n" + "/* c2 */\n" + ")// c1\n" + "/* c2 */\n" + ";// c1\n" + "/* c2 */\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz // c1\n" + " /* c2 */\n" + " ( // c1\n" + " /* c2 */\n" + " ) // c1\n" + "/* c2 */\n" + "; // c1\n" + "/* c2 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz/* c1 */\n" + "// c2\n" + "(/* c1 */\n" + "// c2\n" + ")/* c1 */\n" + "// c2\n" + ";/* c1 */\n" + "// c2\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz /* c1 */\n" + " // c2\n" + " ( /* c1 */\n" + " // c2\n" + " ) /* c1 */\n" + "// c2\n" + "; /* c1 */\n" + "// c2\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz// c1\n" + "// c2\n" + "(// c1\n" + "// c2\n" + ")// c1\n" + "// c2\n" + ";// c1\n" + "// c2\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz // c1\n" + " // c2\n" + " ( // c1\n" + " // c2\n" + " ) // c1\n" + " // c2\n" + "; // c1\n" + " // c2\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz/* c1 */\n" + "/* c2 */\n" + "/* c3 */\n" + "(/* c1 */\n" + "/* c2 */\n" + "/* c3 */\n" + ")/* c1 */\n" + "/* c2 */\n" + "/* c3 */\n" + ";/* c1 */\n" + "/* c2 */\n" + "/* c3 */\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz /* c1 */\n" + " /* c2 */\n" + " /* c3 */\n" + " ( /* c1 */\n" + " /* c2 */\n" + " /* c3 */\n" + " ) /* c1 */\n" + "/* c2 */\n" + "/* c3 */\n" + "; /* c1 */\n" + "/* c2 */\n" + "/* c3 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz// c1\n" + "// c2\n" + "// c3\n" + "(// c1\n" + "// c2\n" + "// c3\n" + ")// c1\n" + "// c2\n" + "// c3\n" + ";// c1\n" + "// c2\n" + "// c3\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz // c1\n" + " // c2\n" + " // c3\n" + " ( // c1\n" + " // c2\n" + " // c3\n" + " ) // c1\n" + " // c2\n" + " // c3\n" + "; // c1\n" + " // c2\n" + " // c3\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(/* c */)/* c */;/* c */\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ( /* c */) /* c */; /* c */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(/* c1 */ /* c2 */)/* c1 */ /* c2 */;/* c1 */ /* c2 */\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ( /* c1 */ /* c2 */) /* c1 */ /* c2 */; /* c1 */ /* c2 " + "*/\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(/* c */\n" + ")/* c */\n" + ";/* c */\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ( /* c */\n" + ") /* c */\n" + "; /* c */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(/* c1 */ /* c2 */\n" + ")/* c1 */ /* c2 */\n" + ";/* c1 */ /* c2 */\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ( /* c1 */ /* c2 */\n" + ") /* c1 */ /* c2 */\n" + "; /* c1 */ /* c2 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(// c\n" + ")// c\n" + ";// c\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ( // c\n" + ") // c\n" + "; // c\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(/* c1 */ // c2\n" + ")/* c1 */ // c2\n" + ";/* c1 */ // c2\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ( /* c1 */ // c2\n" + ") /* c1 */ // c2\n" + "; /* c1 */ // c2\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(\n" + "/* c */)\n" + "/* c */;\n" + "/* c */\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(\n" + "/* c */)\n" + "/* c */;\n" + "/* c */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(\n" + "/* c1 */ /* c2 */)\n" + "/* c1 */ /* c2 */;\n" + "/* c1 */ /* c2 */\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(\n" + "/* c1 */ /* c2 */)\n" + "/* c1 */ /* c2 */;\n" + "/* c1 */ /* c2 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(\n" + "/* c */\n" + ")\n" + "/* c */\n" + ";\n" + "/* c */\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(\n" + " /* c */\n" + ")\n" + "/* c */\n" + ";\n" + "/* c */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(\n" + "/* c1 */ /* c2 */\n" + ")\n" + "/* c1 */ /* c2 */\n" + ";\n" + "/* c1 */ /* c2 */\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(\n" + " /* c1 */ /* c2 */\n" + ")\n" + "/* c1 */ /* c2 */\n" + ";\n" + "/* c1 */ /* c2 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(\n" + "// c\n" + ")\n" + "// c\n" + ";\n" + "// c\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(\n" + " // c\n" + ")\n" + "// c\n" + ";\n" + "// c\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(\n" + "/* c1 */ // c2\n" + ")\n" + "/* c1 */ // c2\n" + ";\n" + "/* c1 */ // c2\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(\n" + " /* c1 */ // c2\n" + ")\n" + "/* c1 */ // c2\n" + ";\n" + "/* c1 */ // c2\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(\n" + "/* c1 */\n" + "/* c2 */\n" + ")\n" + "/* c1 */\n" + "/* c2 */\n" + ";\n" + "/* c1 */\n" + "/* c2 */\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(\n" + " /* c1 */\n" + " /* c2 */\n" + ")\n" + "/* c1 */\n" + "/* c2 */\n" + ";\n" + "/* c1 */\n" + "/* c2 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(\n" + "// c1\n" + "// c2\n" + ")\n" + "// c1\n" + "// c2\n" + ";\n" + "// c1\n" + "// c2\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(\n" + " // c1\n" + " // c2\n" + ")\n" + "// c1\n" + "// c2\n" + ";\n" + "// c1\n" + "// c2\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(/* c1 */\n" + "/* c2 */)/* c1 */\n" + "/* c2 */;/* c1 */\n" + "/* c2 */\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ( /* c1 */\n" + "/* c2 */) /* c1 */\n" + "/* c2 */; /* c1 */\n" + "/* c2 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(// c1\n" + "/* c2 */)// c1\n" + "/* c2 */;// c1\n" + "/* c2 */\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ( // c1\n" + "/* c2 */) // c1\n" + "/* c2 */; // c1\n" + "/* c2 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(/* c1 */\n" + "/* c2 */\n" + "/* c3 */)/* c1 */\n" + "/* c2 */\n" + "/* c3 */;/* c1 */\n" + "/* c2 */\n" + "/* c3 */\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ( /* c1 */\n" + " /* c2 */\n" + "/* c3 */) /* c1 */\n" + "/* c2 */\n" + "/* c3 */; /* c1 */\n" + "/* c2 */\n" + "/* c3 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(/* c1 */\n" + "/* c2 */\n" + ")/* c1 */\n" + "/* c2 */\n" + ";/* c1 */\n" + "/* c2 */\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ( /* c1 */\n" + " /* c2 */\n" + ") /* c1 */\n" + "/* c2 */\n" + "; /* c1 */\n" + "/* c2 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(// c1\n" + "/* c2 */\n" + ")// c1\n" + "/* c2 */\n" + ";// c1\n" + "/* c2 */\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ( // c1\n" + " /* c2 */\n" + ") // c1\n" + "/* c2 */\n" + "; // c1\n" + "/* c2 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(/* c1 */\n" + "// c2\n" + ")/* c1 */\n" + "// c2\n" + ";/* c1 */\n" + "// c2\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ( /* c1 */\n" + " // c2\n" + ") /* c1 */\n" + "// c2\n" + "; /* c1 */\n" + "// c2\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(// c1\n" + "// c2\n" + ")// c1\n" + "// c2\n" + ";// c1\n" + "// c2\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ( // c1\n" + " // c2\n" + ") // c1\n" + " // c2\n" + "; // c1\n" + " // c2\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(/* c1 */\n" + "/* c2 */\n" + "/* c3 */\n" + ")/* c1 */\n" + "/* c2 */\n" + "/* c3 */\n" + ";/* c1 */\n" + "/* c2 */\n" + "/* c3 */\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ( /* c1 */\n" + " /* c2 */\n" + " /* c3 */\n" + ") /* c1 */\n" + "/* c2 */\n" + "/* c3 */\n" + "; /* c1 */\n" + "/* c2 */\n" + "/* c3 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(// c1\n" + "// c2\n" + "// c3\n" + ")// c1\n" + "// c2\n" + "// c3\n" + ";// c1\n" + "// c2\n" + "// c3\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ( // c1\n" + " // c2\n" + " // c3\n" + ") // c1\n" + " // c2\n" + " // c3\n" + "; // c1\n" + " // c2\n" + " // c3\n"}, + + // everywhere, with args + + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz/* c */(/* c */arg1/* c */,/* c */arg2/* c */)/* c */;/* c " + "*/\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz /* c */ ( /* c */\n" + " arg1 /* c */, /* c */\n" + " arg2 /* c */) /* c */; /* c */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz/* c1 */ /* c2 */(/* c1 */ /* c2 */arg1/* c1 */ /* c2 */,/* c1 " + "*/ /* c2 */arg2/* c1 */ /* c2 */)/* c1 */ /* c2 */;/* c1 */ /* c2 */\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz /* c1 */ /* c2 */ ( /* c1 */ /* c2 */\n" + " arg1 /* c1 */ /* c2 */, /* c1 */ /* c2 */\n" + " arg2 /* c1 */ /* c2 */) /* c1 */ /* c2 */; /* c1 */ /* c2 " + "*/\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz/* c */\n" + "(/* c */\n" + "arg1/* c */\n" + ",/* c */\n" + "arg2/* c */\n" + ")/* c */\n" + ";/* c */\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz /* c */\n" + " ( /* c */\n" + " arg1 /* c */\n" + " , /* c */\n" + " arg2 /* c */\n" + " ) /* c */\n" + "; /* c */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz/* c1 */ /* c2 */\n" + "(/* c1 */ /* c2 */\n" + "arg1/* c1 */ /* c2 */\n" + ",/* c1 */ /* c2 */\n" + "arg2/* c1 */ /* c2 */\n" + ")/* c1 */ /* c2 */\n" + ";/* c1 */ /* c2 */\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz /* c1 */ /* c2 */\n" + " ( /* c1 */ /* c2 */\n" + " arg1 /* c1 */ /* c2 */\n" + " , /* c1 */ /* c2 */\n" + " arg2 /* c1 */ /* c2 */\n" + " ) /* c1 */ /* c2 */\n" + "; /* c1 */ /* c2 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz// c\n" + "(// c\n" + "arg1// c\n" + ",// c\n" + "arg2// c\n" + ")// c\n" + ";// c\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz // c\n" + " ( // c\n" + " arg1 // c\n" + " , // c\n" + " arg2 // c\n" + " ) // c\n" + "; // c\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz/* c1 */ // c2\n" + "(/* c1 */ // c2\n" + "arg1/* c1 */ // c2\n" + ",/* c1 */ // c2\n" + "arg2/* c1 */ // c2\n" + ")/* c1 */ // c2\n" + ";/* c1 */ // c2\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz /* c1 */ // c2\n" + " ( /* c1 */ // c2\n" + " arg1 /* c1 */ // c2\n" + " , /* c1 */ // c2\n" + " arg2 /* c1 */ // c2\n" + " ) /* c1 */ // c2\n" + "; /* c1 */ // c2\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz\n" + "/* c */(\n" + "/* c */arg1\n" + "/* c */,\n" + "/* c */arg2\n" + "/* c */)\n" + "/* c */;\n" + "/* c */\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz\n" + " /* c */ (\n" + " /* c */ arg1\n" + " /* c */,\n" + " /* c */ arg2\n" + " /* c */)\n" + "/* c */;\n" + "/* c */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz\n" + "/* c1 */ /* c2 */(\n" + "/* c1 */ /* c2 */arg1\n" + "/* c1 */ /* c2 */,\n" + "/* c1 */ /* c2 */arg2\n" + "/* c1 */ /* c2 */)\n" + "/* c1 */ /* c2 */;\n" + "/* c1 */ /* c2 */\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz\n" + " /* c1 */ /* c2 */ (\n" + " /* c1 */ /* c2 */ arg1\n" + " /* c1 */ /* c2 */,\n" + " /* c1 */ /* c2 */ arg2\n" + " /* c1 */ /* c2 */)\n" + "/* c1 */ /* c2 */;\n" + "/* c1 */ /* c2 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz\n" + "/* c */\n" + "(\n" + "/* c */\n" + "arg1\n" + "/* c */\n" + ",\n" + "/* c */\n" + "arg2\n" + "/* c */\n" + ")\n" + "/* c */\n" + ";\n" + "/* c */\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz\n" + " /* c */\n" + " (\n" + " /* c */\n" + " arg1\n" + " /* c */\n" + " ,\n" + " /* c */\n" + " arg2\n" + " /* c */\n" + " )\n" + "/* c */\n" + ";\n" + "/* c */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz\n" + "/* c1 */ /* c2 */\n" + "(\n" + "/* c1 */ /* c2 */\n" + "arg1\n" + "/* c1 */ /* c2 */\n" + ",\n" + "/* c1 */ /* c2 */\n" + "arg2\n" + "/* c1 */ /* c2 */\n" + ")\n" + "/* c1 */ /* c2 */\n" + ";\n" + "/* c1 */ /* c2 */\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz\n" + " /* c1 */ /* c2 */\n" + " (\n" + " /* c1 */ /* c2 */\n" + " arg1\n" + " /* c1 */ /* c2 */\n" + " ,\n" + " /* c1 */ /* c2 */\n" + " arg2\n" + " /* c1 */ /* c2 */\n" + " )\n" + "/* c1 */ /* c2 */\n" + ";\n" + "/* c1 */ /* c2 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz\n" + "// c\n" + "(\n" + "// c\n" + "arg1\n" + "// c\n" + ",\n" + "// c\n" + "arg2\n" + "// c\n" + ")\n" + "// c\n" + ";\n" + "// c\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz\n" + " // c\n" + " (\n" + " // c\n" + " arg1\n" + " // c\n" + " ,\n" + " // c\n" + " arg2\n" + " // c\n" + " )\n" + "// c\n" + ";\n" + "// c\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz\n" + "/* c1 */ // c2\n" + "(\n" + "/* c1 */ // c2\n" + "arg1\n" + "/* c1 */ // c2\n" + ",\n" + "/* c1 */ // c2\n" + "arg2\n" + "/* c1 */ // c2\n" + ")\n" + "/* c1 */ // c2\n" + ";\n" + "/* c1 */ // c2\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz\n" + " /* c1 */ // c2\n" + " (\n" + " /* c1 */ // c2\n" + " arg1\n" + " /* c1 */ // c2\n" + " ,\n" + " /* c1 */ // c2\n" + " arg2\n" + " /* c1 */ // c2\n" + " )\n" + "/* c1 */ // c2\n" + ";\n" + "/* c1 */ // c2\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz\n" + "/* c1 */\n" + "/* c2 */\n" + "(\n" + "/* c1 */\n" + "/* c2 */\n" + "arg1\n" + "/* c1 */\n" + "/* c2 */\n" + ",\n" + "/* c1 */\n" + "/* c2 */\n" + "arg2\n" + "/* c1 */\n" + "/* c2 */\n" + ")\n" + "/* c1 */\n" + "/* c2 */\n" + ";\n" + "/* c1 */\n" + "/* c2 */\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz\n" + " /* c1 */\n" + " /* c2 */\n" + " (\n" + " /* c1 */\n" + " /* c2 */\n" + " arg1\n" + " /* c1 */\n" + " /* c2 */\n" + " ,\n" + " /* c1 */\n" + " /* c2 */\n" + " arg2\n" + " /* c1 */\n" + " /* c2 */\n" + " )\n" + "/* c1 */\n" + "/* c2 */\n" + ";\n" + "/* c1 */\n" + "/* c2 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz\n" + "// c1\n" + "// c2\n" + "(\n" + "// c1\n" + "// c2\n" + "arg1\n" + "// c1\n" + "// c2\n" + ",\n" + "// c1\n" + "// c2\n" + "arg2\n" + "// c1\n" + "// c2\n" + ")\n" + "// c1\n" + "// c2\n" + ";\n" + "// c1\n" + "// c2\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz\n" + " // c1\n" + " // c2\n" + " (\n" + " // c1\n" + " // c2\n" + " arg1\n" + " // c1\n" + " // c2\n" + " ,\n" + " // c1\n" + " // c2\n" + " arg2\n" + " // c1\n" + " // c2\n" + " )\n" + "// c1\n" + "// c2\n" + ";\n" + "// c1\n" + "// c2\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz/* c1 */\n" + "/* c2 */(/* c1 */\n" + "/* c2 */arg1/* c1 */\n" + "/* c2 */,/* c1 */\n" + "/* c2 */arg2/* c1 */\n" + "/* c2 */)/* c1 */\n" + "/* c2 */;/* c1 */\n" + "/* c2 */\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz /* c1 */\n" + " /* c2 */ ( /* c1 */\n" + " /* c2 */ arg1 /* c1 */\n" + " /* c2 */, /* c1 */\n" + " /* c2 */ arg2 /* c1 */\n" + " /* c2 */) /* c1 */\n" + "/* c2 */; /* c1 */\n" + "/* c2 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz// c1\n" + "/* c2 */(// c1\n" + "/* c2 */arg1// c1\n" + "/* c2 */,// c1\n" + "/* c2 */arg2// c1\n" + "/* c2 */)// c1\n" + "/* c2 */;// c1\n" + "/* c2 */\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz // c1\n" + " /* c2 */ ( // c1\n" + " /* c2 */ arg1 // c1\n" + " /* c2 */, // c1\n" + " /* c2 */ arg2 // c1\n" + " /* c2 */) // c1\n" + "/* c2 */; // c1\n" + "/* c2 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz/* c1 */\n" + "/* c2 */\n" + "/* c3 */(/* c1 */\n" + "/* c2 */\n" + "/* c3 */arg1/* c1 */\n" + "/* c2 */\n" + "/* c3 */,/* c1 */\n" + "/* c2 */\n" + "/* c3 */arg2/* c1 */\n" + "/* c2 */\n" + "/* c3 */)/* c1 */\n" + "/* c2 */\n" + "/* c3 */;/* c1 */\n" + "/* c2 */\n" + "/* c3 */\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz /* c1 */\n" + " /* c2 */\n" + " /* c3 */ ( /* c1 */\n" + " /* c2 */\n" + " /* c3 */ arg1 /* c1 */\n" + " /* c2 */\n" + " /* c3 */, /* c1 */\n" + " /* c2 */\n" + " /* c3 */ arg2 /* c1 */\n" + " /* c2 */\n" + " /* c3 */) /* c1 */\n" + "/* c2 */\n" + "/* c3 */; /* c1 */\n" + "/* c2 */\n" + "/* c3 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz/* c1 */\n" + "/* c2 */\n" + "(/* c1 */\n" + "/* c2 */\n" + "arg1/* c1 */\n" + "/* c2 */\n" + ",/* c1 */\n" + "/* c2 */\n" + "arg2/* c1 */\n" + "/* c2 */\n" + ")/* c1 */\n" + "/* c2 */\n" + ";/* c1 */\n" + "/* c2 */\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz /* c1 */\n" + " /* c2 */\n" + " ( /* c1 */\n" + " /* c2 */\n" + " arg1 /* c1 */\n" + " /* c2 */\n" + " , /* c1 */\n" + " /* c2 */\n" + " arg2 /* c1 */\n" + " /* c2 */\n" + " ) /* c1 */\n" + "/* c2 */\n" + "; /* c1 */\n" + "/* c2 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz// c1\n" + "/* c2 */\n" + "(// c1\n" + "/* c2 */\n" + "arg1// c1\n" + "/* c2 */\n" + ",// c1\n" + "/* c2 */\n" + "arg2// c1\n" + "/* c2 */\n" + ")// c1\n" + "/* c2 */\n" + ";// c1\n" + "/* c2 */\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz // c1\n" + " /* c2 */\n" + " ( // c1\n" + " /* c2 */\n" + " arg1 // c1\n" + " /* c2 */\n" + " , // c1\n" + " /* c2 */\n" + " arg2 // c1\n" + " /* c2 */\n" + " ) // c1\n" + "/* c2 */\n" + "; // c1\n" + "/* c2 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz/* c1 */\n" + "// c2\n" + "(/* c1 */\n" + "// c2\n" + "arg1/* c1 */\n" + "// c2\n" + ",/* c1 */\n" + "// c2\n" + "arg2/* c1 */\n" + "// c2\n" + ")/* c1 */\n" + "// c2\n" + ";/* c1 */\n" + "// c2\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz /* c1 */\n" + " // c2\n" + " ( /* c1 */\n" + " // c2\n" + " arg1 /* c1 */\n" + " // c2\n" + " , /* c1 */\n" + " // c2\n" + " arg2 /* c1 */\n" + " // c2\n" + " ) /* c1 */\n" + "// c2\n" + "; /* c1 */\n" + "// c2\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz// c1\n" + "// c2\n" + "(// c1\n" + "// c2\n" + "arg1// c1\n" + "// c2\n" + ",// c1\n" + "// c2\n" + "arg2// c1\n" + "// c2\n" + ")// c1\n" + "// c2\n" + ";// c1\n" + "// c2\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz // c1\n" + " // c2\n" + " ( // c1\n" + " // c2\n" + " arg1 // c1\n" + " // c2\n" + " , // c1\n" + " // c2\n" + " arg2 // c1\n" + " // c2\n" + " ) // c1\n" + " // c2\n" + "; // c1\n" + " // c2\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz/* c1 */\n" + "/* c2 */\n" + "/* c3 */\n" + "(/* c1 */\n" + "/* c2 */\n" + "/* c3 */\n" + "arg1/* c1 */\n" + "/* c2 */\n" + "/* c3 */\n" + ",/* c1 */\n" + "/* c2 */\n" + "/* c3 */\n" + "arg2/* c1 */\n" + "/* c2 */\n" + "/* c3 */\n" + ")/* c1 */\n" + "/* c2 */\n" + "/* c3 */\n" + ";/* c1 */\n" + "/* c2 */\n" + "/* c3 */\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz /* c1 */\n" + " /* c2 */\n" + " /* c3 */\n" + " ( /* c1 */\n" + " /* c2 */\n" + " /* c3 */\n" + " arg1 /* c1 */\n" + " /* c2 */\n" + " /* c3 */\n" + " , /* c1 */\n" + " /* c2 */\n" + " /* c3 */\n" + " arg2 /* c1 */\n" + " /* c2 */\n" + " /* c3 */\n" + " ) /* c1 */\n" + "/* c2 */\n" + "/* c3 */\n" + "; /* c1 */\n" + "/* c2 */\n" + "/* c3 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "$foobarbaz// c1\n" + "// c2\n" + "// c3\n" + "(// c1\n" + "// c2\n" + "// c3\n" + "arg1// c1\n" + "// c2\n" + "// c3\n" + ",// c1\n" + "// c2\n" + "// c3\n" + "arg2// c1\n" + "// c2\n" + "// c3\n" + ")// c1\n" + "// c2\n" + "// c3\n" + ";// c1\n" + "// c2\n" + "// c3\n", + "// verilog_syntax: parse-as-module-body\n" + "$foobarbaz // c1\n" + " // c2\n" + " // c3\n" + " ( // c1\n" + " // c2\n" + " // c3\n" + " arg1 // c1\n" + " // c2\n" + " // c3\n" + " , // c1\n" + " // c2\n" + " // c3\n" + " arg2 // c1\n" + " // c2\n" + " // c3\n" + " ) // c1\n" + " // c2\n" + " // c3\n" + "; // c1\n" + " // c2\n" + " // c3\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(/* c */arg1/* c */,/* c */arg2/* c */)/* c */;/* c */\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ( /* c */\n" + " arg1 /* c */, /* c */\n" + " arg2 /* c */) /* c */; /* c */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(/* c1 */ /* c2 */arg1/* c1 */ /* c2 */,/* c1 */ /* c2 " + "*/arg2/* c1 */ /* c2 */)/* c1 */ /* c2 */;/* c1 */ /* c2 */\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ( /* c1 */ /* c2 */\n" + " arg1 /* c1 */ /* c2 */, /* c1 */ /* c2 */\n" + " arg2 /* c1 */ /* c2 */) /* c1 */ /* c2 */; /* c1 */ /* c2 " + "*/\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(/* c */\n" + "arg1/* c */\n" + ",/* c */\n" + "arg2/* c */\n" + ")/* c */\n" + ";/* c */\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ( /* c */\n" + " arg1 /* c */\n" + " , /* c */\n" + " arg2 /* c */\n" + ") /* c */\n" + "; /* c */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(/* c1 */ /* c2 */\n" + "arg1/* c1 */ /* c2 */\n" + ",/* c1 */ /* c2 */\n" + "arg2/* c1 */ /* c2 */\n" + ")/* c1 */ /* c2 */\n" + ";/* c1 */ /* c2 */\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ( /* c1 */ /* c2 */\n" + " arg1 /* c1 */ /* c2 */\n" + " , /* c1 */ /* c2 */\n" + " arg2 /* c1 */ /* c2 */\n" + ") /* c1 */ /* c2 */\n" + "; /* c1 */ /* c2 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(// c\n" + "arg1// c\n" + ",// c\n" + "arg2// c\n" + ")// c\n" + ";// c\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ( // c\n" + " arg1 // c\n" + " , // c\n" + " arg2 // c\n" + ") // c\n" + "; // c\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(/* c1 */ // c2\n" + "arg1/* c1 */ // c2\n" + ",/* c1 */ // c2\n" + "arg2/* c1 */ // c2\n" + ")/* c1 */ // c2\n" + ";/* c1 */ // c2\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ( /* c1 */ // c2\n" + " arg1 /* c1 */ // c2\n" + " , /* c1 */ // c2\n" + " arg2 /* c1 */ // c2\n" + ") /* c1 */ // c2\n" + "; /* c1 */ // c2\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(\n" + "/* c */arg1\n" + "/* c */,\n" + "/* c */arg2\n" + "/* c */)\n" + "/* c */;\n" + "/* c */\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(\n" + " /* c */ arg1\n" + " /* c */,\n" + " /* c */ arg2\n" + "/* c */)\n" + "/* c */;\n" + "/* c */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(\n" + "/* c1 */ /* c2 */arg1\n" + "/* c1 */ /* c2 */,\n" + "/* c1 */ /* c2 */arg2\n" + "/* c1 */ /* c2 */)\n" + "/* c1 */ /* c2 */;\n" + "/* c1 */ /* c2 */\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(\n" + " /* c1 */ /* c2 */ arg1\n" + " /* c1 */ /* c2 */,\n" + " /* c1 */ /* c2 */ arg2\n" + "/* c1 */ /* c2 */)\n" + "/* c1 */ /* c2 */;\n" + "/* c1 */ /* c2 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(\n" + "/* c */\n" + "arg1\n" + "/* c */\n" + ",\n" + "/* c */\n" + "arg2\n" + "/* c */\n" + ")\n" + "/* c */\n" + ";\n" + "/* c */\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(\n" + " /* c */\n" + " arg1\n" + " /* c */\n" + " ,\n" + " /* c */\n" + " arg2\n" + " /* c */\n" + ")\n" + "/* c */\n" + ";\n" + "/* c */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(\n" + "/* c1 */ /* c2 */\n" + "arg1\n" + "/* c1 */ /* c2 */\n" + ",\n" + "/* c1 */ /* c2 */\n" + "arg2\n" + "/* c1 */ /* c2 */\n" + ")\n" + "/* c1 */ /* c2 */\n" + ";\n" + "/* c1 */ /* c2 */\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(\n" + " /* c1 */ /* c2 */\n" + " arg1\n" + " /* c1 */ /* c2 */\n" + " ,\n" + " /* c1 */ /* c2 */\n" + " arg2\n" + " /* c1 */ /* c2 */\n" + ")\n" + "/* c1 */ /* c2 */\n" + ";\n" + "/* c1 */ /* c2 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(\n" + "// c\n" + "arg1\n" + "// c\n" + ",\n" + "// c\n" + "arg2\n" + "// c\n" + ")\n" + "// c\n" + ";\n" + "// c\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(\n" + " // c\n" + " arg1\n" + " // c\n" + " ,\n" + " // c\n" + " arg2\n" + " // c\n" + ")\n" + "// c\n" + ";\n" + "// c\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(\n" + "/* c1 */ // c2\n" + "arg1\n" + "/* c1 */ // c2\n" + ",\n" + "/* c1 */ // c2\n" + "arg2\n" + "/* c1 */ // c2\n" + ")\n" + "/* c1 */ // c2\n" + ";\n" + "/* c1 */ // c2\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(\n" + " /* c1 */ // c2\n" + " arg1\n" + " /* c1 */ // c2\n" + " ,\n" + " /* c1 */ // c2\n" + " arg2\n" + " /* c1 */ // c2\n" + ")\n" + "/* c1 */ // c2\n" + ";\n" + "/* c1 */ // c2\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(\n" + "/* c1 */\n" + "/* c2 */\n" + "arg1\n" + "/* c1 */\n" + "/* c2 */\n" + ",\n" + "/* c1 */\n" + "/* c2 */\n" + "arg2\n" + "/* c1 */\n" + "/* c2 */\n" + ")\n" + "/* c1 */\n" + "/* c2 */\n" + ";\n" + "/* c1 */\n" + "/* c2 */\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(\n" + " /* c1 */\n" + " /* c2 */\n" + " arg1\n" + " /* c1 */\n" + " /* c2 */\n" + " ,\n" + " /* c1 */\n" + " /* c2 */\n" + " arg2\n" + " /* c1 */\n" + " /* c2 */\n" + ")\n" + "/* c1 */\n" + "/* c2 */\n" + ";\n" + "/* c1 */\n" + "/* c2 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(\n" + "// c1\n" + "// c2\n" + "arg1\n" + "// c1\n" + "// c2\n" + ",\n" + "// c1\n" + "// c2\n" + "arg2\n" + "// c1\n" + "// c2\n" + ")\n" + "// c1\n" + "// c2\n" + ";\n" + "// c1\n" + "// c2\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(\n" + " // c1\n" + " // c2\n" + " arg1\n" + " // c1\n" + " // c2\n" + " ,\n" + " // c1\n" + " // c2\n" + " arg2\n" + " // c1\n" + " // c2\n" + ")\n" + "// c1\n" + "// c2\n" + ";\n" + "// c1\n" + "// c2\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(/* c1 */\n" + "/* c2 */arg1/* c1 */\n" + "/* c2 */,/* c1 */\n" + "/* c2 */arg2/* c1 */\n" + "/* c2 */)/* c1 */\n" + "/* c2 */;/* c1 */\n" + "/* c2 */\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ( /* c1 */\n" + " /* c2 */ arg1 /* c1 */\n" + " /* c2 */, /* c1 */\n" + " /* c2 */ arg2 /* c1 */\n" + "/* c2 */) /* c1 */\n" + "/* c2 */; /* c1 */\n" + "/* c2 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(// c1\n" + "/* c2 */arg1// c1\n" + "/* c2 */,// c1\n" + "/* c2 */arg2// c1\n" + "/* c2 */)// c1\n" + "/* c2 */;// c1\n" + "/* c2 */\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ( // c1\n" + " /* c2 */ arg1 // c1\n" + " /* c2 */, // c1\n" + " /* c2 */ arg2 // c1\n" + "/* c2 */) // c1\n" + "/* c2 */; // c1\n" + "/* c2 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(/* c1 */\n" + "/* c2 */\n" + "/* c3 */arg1/* c1 */\n" + "/* c2 */\n" + "/* c3 */,/* c1 */\n" + "/* c2 */\n" + "/* c3 */arg2/* c1 */\n" + "/* c2 */\n" + "/* c3 */)/* c1 */\n" + "/* c2 */\n" + "/* c3 */;/* c1 */\n" + "/* c2 */\n" + "/* c3 */\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ( /* c1 */\n" + " /* c2 */\n" + " /* c3 */ arg1 /* c1 */\n" + " /* c2 */\n" + " /* c3 */, /* c1 */\n" + " /* c2 */\n" + " /* c3 */ arg2 /* c1 */\n" + " /* c2 */\n" + "/* c3 */) /* c1 */\n" + "/* c2 */\n" + "/* c3 */; /* c1 */\n" + "/* c2 */\n" + "/* c3 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(/* c1 */\n" + "/* c2 */\n" + "arg1/* c1 */\n" + "/* c2 */\n" + ",/* c1 */\n" + "/* c2 */\n" + "arg2/* c1 */\n" + "/* c2 */\n" + ")/* c1 */\n" + "/* c2 */\n" + ";/* c1 */\n" + "/* c2 */\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ( /* c1 */\n" + " /* c2 */\n" + " arg1 /* c1 */\n" + " /* c2 */\n" + " , /* c1 */\n" + " /* c2 */\n" + " arg2 /* c1 */\n" + " /* c2 */\n" + ") /* c1 */\n" + "/* c2 */\n" + "; /* c1 */\n" + "/* c2 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(// c1\n" + "/* c2 */\n" + "arg1// c1\n" + "/* c2 */\n" + ",// c1\n" + "/* c2 */\n" + "arg2// c1\n" + "/* c2 */\n" + ")// c1\n" + "/* c2 */\n" + ";// c1\n" + "/* c2 */\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ( // c1\n" + " /* c2 */\n" + " arg1 // c1\n" + " /* c2 */\n" + " , // c1\n" + " /* c2 */\n" + " arg2 // c1\n" + " /* c2 */\n" + ") // c1\n" + "/* c2 */\n" + "; // c1\n" + "/* c2 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(/* c1 */\n" + "// c2\n" + "arg1/* c1 */\n" + "// c2\n" + ",/* c1 */\n" + "// c2\n" + "arg2/* c1 */\n" + "// c2\n" + ")/* c1 */\n" + "// c2\n" + ";/* c1 */\n" + "// c2\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ( /* c1 */\n" + " // c2\n" + " arg1 /* c1 */\n" + " // c2\n" + " , /* c1 */\n" + " // c2\n" + " arg2 /* c1 */\n" + " // c2\n" + ") /* c1 */\n" + "// c2\n" + "; /* c1 */\n" + "// c2\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(// c1\n" + "// c2\n" + "arg1// c1\n" + "// c2\n" + ",// c1\n" + "// c2\n" + "arg2// c1\n" + "// c2\n" + ")// c1\n" + "// c2\n" + ";// c1\n" + "// c2\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ( // c1\n" + " // c2\n" + " arg1 // c1\n" + " // c2\n" + " , // c1\n" + " // c2\n" + " arg2 // c1\n" + " // c2\n" + ") // c1\n" + " // c2\n" + "; // c1\n" + " // c2\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(/* c1 */\n" + "/* c2 */\n" + "/* c3 */\n" + "arg1/* c1 */\n" + "/* c2 */\n" + "/* c3 */\n" + ",/* c1 */\n" + "/* c2 */\n" + "/* c3 */\n" + "arg2/* c1 */\n" + "/* c2 */\n" + "/* c3 */\n" + ")/* c1 */\n" + "/* c2 */\n" + "/* c3 */\n" + ";/* c1 */\n" + "/* c2 */\n" + "/* c3 */\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ( /* c1 */\n" + " /* c2 */\n" + " /* c3 */\n" + " arg1 /* c1 */\n" + " /* c2 */\n" + " /* c3 */\n" + " , /* c1 */\n" + " /* c2 */\n" + " /* c3 */\n" + " arg2 /* c1 */\n" + " /* c2 */\n" + " /* c3 */\n" + ") /* c1 */\n" + "/* c2 */\n" + "/* c3 */\n" + "; /* c1 */\n" + "/* c2 */\n" + "/* c3 */\n"}, + {"// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ(// c1\n" + "// c2\n" + "// c3\n" + "arg1// c1\n" + "// c2\n" + "// c3\n" + ",// c1\n" + "// c2\n" + "// c3\n" + "arg2// c1\n" + "// c2\n" + "// c3\n" + ")// c1\n" + "// c2\n" + "// c3\n" + ";// c1\n" + "// c2\n" + "// c3\n", + "// verilog_syntax: parse-as-module-body\n" + "`FOOBARBAZ( // c1\n" + " // c2\n" + " // c3\n" + " arg1 // c1\n" + " // c2\n" + " // c3\n" + " , // c1\n" + " // c2\n" + " // c3\n" + " arg2 // c1\n" + " // c2\n" + " // c3\n" + ") // c1\n" + " // c2\n" + " // c3\n" + "; // c1\n" + " // c2\n" + " // c3\n"}, + {"module indent();\n" + " reg a;\n" + " reg [32:0] b;\n" + " wire c;\n" + " wire d = e ? kFoo : kBar;\n" + "endmodule\n", + "module indent ();\n" + " reg a;\n" + " reg [32:0] b;\n" + " wire c;\n" + " wire d = e ? kFoo : kBar;\n" + "endmodule\n"}, + + {"class C; T1 b; logic [$] a; T1 [$] c; endclass\n", + "class C;\n" + " T1 b;\n" + " logic [$] a;\n" + " T1 [$] c;\n" + "endclass\n"}, + {"class C;\n" + " T1 b; //test\n" + " logic [$] a; //test\n" + " T1 [$] c; //test\n" + "endclass\n", + "class C;\n" + " T1 b; //test\n" + " logic [$] a; //test\n" + " T1 [$] c; //test\n" + "endclass\n"}, + {"class C;\n" + " T1\n" + " b;\n" + " logic\n" + " [$]\n" + " a;\n" + " T1\n" + " [$]\n" + " c;\n" + "endclass\n", + "class C;\n" + " T1 b;\n" + " logic [$] a;\n" + " T1 [$] c;\n" + "endclass\n"}, + {"class C;\n" + " logic/*t*/ [0 : 1] /*t*/\n" + " a;/*t*/\n" + " T1/*t*/[0 : 1]/*t*/\n" + " c;/*t*/\n" + "endclass\n", + "class C;\n" + " logic/*t*/ [0 : 1] /*t*/ a; /*t*/\n" + " T1/*t*/ [0 : 1] /*t*/ c; /*t*/\n" + "endclass\n"}, + {"always @(*/*t*/) begin\n" + "end\n", + "always @(* /*t*/) begin\n" + "end\n"}, + {"always @(/*t*/*) begin\n" + "end\n", + "always @( /*t*/ *) begin\n" + "end\n"}, + {"always @(/*t*/*/*t*/) begin\n" + "end\n", + "always @( /*t*/ * /*t*/) begin\n" + "end\n"}, + {"always @(*) begin\n" + "end\n", + "always @(*) begin\n" + "end\n"}, + {"always @(* ) begin\n" + "end\n", + "always @(*) begin\n" + "end\n"}, + {"always @( *) begin\n" + "end\n", + "always @(*) begin\n" + "end\n"}, + {"always @( * ) begin\n" + "end\n", + "always @(*) begin\n" + "end\n"}, + {"always @( /*t*/ * /*t*/ ) begin\n" + "end\n", + "always @( /*t*/ * /*t*/) begin\n" + "end\n"}, + { + // Don't touch verilog_format:off region #1538 + R"( +module testcode; + // verilog_format: off + assign a = b + & c; + // verilog_format: on + assign e = d; +endmodule +)", + R"( +module testcode; + // verilog_format: off + assign a = b + & c; + // verilog_format: on + assign e = d; +endmodule +)", + + }, + + // ----------------------------------------------------------------- +}; + +TEST(FormatterEndToEndTest, DisableFormatterTestCases) { + RunFormatterTestCases40(kDisableFormatterTestCases); +} + +} // namespace +} // namespace formatter +} // namespace verilog
diff --git a/verible/verilog/formatting/formatter_function_task_test.cc b/verible/verilog/formatting/formatter_function_task_test.cc new file mode 100644 index 0000000..88e30bb --- /dev/null +++ b/verible/verilog/formatting/formatter_function_task_test.cc
@@ -0,0 +1,2234 @@ +// Copyright 2017-2026 The Verible Authors. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Test cases in this file should be *insensitive* to wrapping penalties. +// Penalty-sensitive tests belong in formatter-tuning_test.cc. + +#include "gtest/gtest.h" +#include "verible/verilog/formatting/formatter-test-utils.h" + +namespace verilog { +namespace formatter { +namespace { + +static constexpr FormatterTestCase kFunctionTaskFormatterTestCases[] = { + // function test cases + {"function f ;endfunction", "function f;\nendfunction\n"}, + {"function f ;endfunction: f", "function f;\nendfunction : f\n"}, + {"function f ( );endfunction", "function f();\nendfunction\n"}, + {"function f (input bit x);endfunction", + "function f(input bit x);\nendfunction\n"}, + {"function f (input bit x,logic y );endfunction", + "function f(input bit x, logic y);\nendfunction\n"}, + {"function f;\n// statement comment\nendfunction\n", + "function f;\n" + " // statement comment\n" // indented + "endfunction\n"}, + {"function f();\n// statement comment\nendfunction\n", + "function f();\n" + " // statement comment\n" // indented + "endfunction\n"}, + {"function f(input int x);\n" + "// statement comment\n" + "f=x;\n" + "// statement comment\n" + "endfunction\n", + "function f(input int x);\n" + " // statement comment\n" // indented + " f = x;\n" + " // statement comment\n" // indented + "endfunction\n"}, + {// line breaks around assignments + "function f;a=b;c+=d;endfunction", + "function f;\n" + " a = b;\n" + " c += d;\n" + "endfunction\n"}, + {"function f;a&=b;c=d;endfunction", + "function f;\n" + " a &= b;\n" + " c = d;\n" + "endfunction\n"}, + {"function f;a<<=b;c=b;d>>>=b;endfunction", + "function f;\n" + " a <<= b;\n" + " c = b;\n" + " d >>>= b;\n" + "endfunction\n"}, + {// port declaration exceeds line length limit + "function f (loooong_type if_it_fits_I_sits);endfunction", + "function f(\n" + " loooong_type if_it_fits_I_sits);\n" + "endfunction\n"}, + {"function\nvoid\tspace;a=( b+c )\n;endfunction :space\n", + "function void space;\n" + " a = (b + c);\n" + "endfunction : space\n"}, + {"function\nvoid\twarranty;return to_sender\n;endfunction :warranty\n", + "function void warranty;\n" + " return to_sender;\n" + "endfunction : warranty\n"}, + {// if statement that fits on one line + "function if_i_fits_i_sits;" + "if(x)y=x;" + "endfunction", + "function if_i_fits_i_sits;\n" + " if (x) y = x;\n" + "endfunction\n"}, + {// for loop + "function\nvoid\twarranty;for(j=0; j<k; --k)begin " + "++j\n;end endfunction :warranty\n", + "function void warranty;\n" + " for (j = 0; j < k; --k) begin\n" + " ++j;\n" + " end\n" + "endfunction : warranty\n"}, + {// for loop that needs wrapping + "function\nvoid\twarranty;for(jjjjj=0; jjjjj<kkkkk; --kkkkk)begin " + "++j\n;end endfunction :warranty\n", + "function void warranty;\n" + " for (\n" + " jjjjj = 0; jjjjj < kkkkk; --kkkkk\n" + " ) begin\n" + " ++j;\n" + " end\n" + "endfunction : warranty\n"}, + {// for loop that needs more wrapping + "function\nvoid\twarranty;" + "for(jjjjjjjj=0; jjjjjjjj<kkkkkkkk; --kkkkkkkk)begin " + "++j\n;end endfunction :warranty\n", + "function void warranty;\n" + " for (\n" + " jjjjjjjj = 0;\n" + " jjjjjjjj < kkkkkkkk;\n" + " --kkkkkkkk\n" + " ) begin\n" + " ++j;\n" + " end\n" + "endfunction : warranty\n"}, + {// for loop that fits on one line + "function loop_fits;" + "for(x=0;x<N;++x) y=x;" + "endfunction", + "function loop_fits;\n" + " for (x = 0; x < N; ++x) y = x;\n" + "endfunction\n"}, + {// for loop that would fit on one line, but is force-split with //comment + "function loop_fits;" + "for(x=0;x<N;++x) //\n y=x;" + "endfunction", + "function loop_fits;\n" + " for (x = 0; x < N; ++x) //\n" + " y = x;\n" + "endfunction\n"}, + {// for loop with function call in initializer + "function void looper(); " + "for (int i=f(n); i>=0; i -- ) begin end " + "endfunction", + "function void looper();\n" + " for (int i = f(n); i >= 0; i--) begin\n" + " end\n" + "endfunction\n"}, + {// for loop with function call in condition + "function void looper(); " + "for (int i=0; i<f(m); i -- ) begin end " + "endfunction", + "function void looper();\n" + " for (int i = 0; i < f(m); i--) begin\n" + " end\n" + "endfunction\n"}, + {// for loop with an attribute instance in the initializer. + // Regression: this used to abort with a CHECK failure while reshaping + // the kForSpec partitions when an attribute appears in the header. + "module m; initial for(int i=0(* a *);i<4;i++) x=i; endmodule", + "module m;\n" + " initial\n" + " for (int i = 0 (* a *); i < 4; i++)\n" + " x = i;\n" + "endmodule\n"}, + {// forever loop + "function\nvoid\tforevah;forever begin " + "++k\n;end endfunction\n", + "function void forevah;\n" + " forever begin\n" + " ++k;\n" + " end\n" + "endfunction\n"}, + {// forever loop + "function\nvoid\tforevah;forever " + "++k\n;endfunction\n", + "function void forevah;\n" + " forever ++k;\n" + "endfunction\n"}, + {// forever loop, forced break + "function\nvoid\tforevah;forever //\n" + "++k\n;endfunction\n", + "function void forevah;\n" + " forever //\n" + " ++k;\n" + "endfunction\n"}, + {// repeat loop + "function\nvoid\tpete;repeat(3) begin " + "++k\n;end endfunction\n", + "function void pete;\n" + " repeat (3) begin\n" + " ++k;\n" + " end\n" + "endfunction\n"}, + {// repeat loop + "function\nvoid\tpete;repeat(3) " + "++k\n;endfunction\n", + "function void pete;\n" + " repeat (3)++k;\n" // TODO(fangism): space before ++ + "endfunction\n"}, + {// repeat loop, forced break + "function\nvoid\tpete;repeat(3)//\n" + "++k\n;endfunction\n", + "function void pete;\n" + " repeat (3) //\n" + " ++k;\n" + "endfunction\n"}, + {// while loop + "function\nvoid\twily;while( coyote ) begin " + "++super_genius\n;end endfunction\n", + "function void wily;\n" + " while (coyote) begin\n" + " ++super_genius;\n" + " end\n" + "endfunction\n"}, + {// while loop + "function\nvoid\twily;while( coyote ) " + "++ super_genius\n; endfunction\n", + "function void wily;\n" + " while (coyote)++super_genius;\n" // TODO(fangism): space before ++ + "endfunction\n"}, + {// while loop, forced break + "function\nvoid\twily;while( coyote ) //\n " + "++ super_genius\n; endfunction\n", + "function void wily;\n" + " while (coyote) //\n" + " ++super_genius;\n" + "endfunction\n"}, + {// do-while loop + "function\nvoid\tdonot;do begin " + "++s\n;end while( z);endfunction\n", + "function void donot;\n" + " do begin\n" + " ++s;\n" + " end while (z);\n" + "endfunction\n"}, + {// do-while loop, single statement + "function\nvoid\tdonot;do " + "++s\n; while( z);endfunction\n", + "function void donot;\n" + " do ++s; while (z);\n" + "endfunction\n"}, + {// do-while loop, single statement, forced break + "function\nvoid\tdonot;do " + "++s\n;//\n while( z);endfunction\n", + "function void donot;\n" + " do\n" + " ++s; //\n" + " while (z);\n" + "endfunction\n"}, + {// foreach loop + "function\nvoid\tforeacher;foreach( m [n] ) begin " + "++m\n;end endfunction\n", + "function void foreacher;\n" + " foreach (m[n]) begin\n" + " ++m;\n" + " end\n" + "endfunction\n"}, + {// spaces in condition expression + "function f; return {a}? {b} :{ c };endfunction", + "function f;\n" + " return {a} ? {b} : {c};\n" + "endfunction\n"}, + {"task t;endtask", + "task t;\n" + "endtask\n"}, + {"task t ( );endtask", + "task t();\n" + "endtask\n"}, + {"task t (input bit drill ) ;endtask", + "task t(input bit drill);\n" + "endtask\n"}, + {"task t; ## 100 ;endtask", + "task t;\n" + " ##100;\n" + "endtask\n"}, + {"task t; ## (1+1) ;endtask", // delay expression + "task t;\n" + " ##(1 + 1);\n" + "endtask\n"}, + {"task t; ## delay_value ;endtask", + "task t;\n" + " ##delay_value;\n" + "endtask\n"}, + {"task t; ## `DELAY_VALUE ;endtask", + "task t;\n" + " ##`DELAY_VALUE;\n" + "endtask\n"}, + {"task t;\n" + "`uvm_error( foo,bar);\n" + "endtask\n", + "task t;\n" + " `uvm_error(foo, bar);\n" + "endtask\n"}, + {"task t;\n" + "`uvm_error(foo,bar)\n" + ";\n" // null statement + "endtask\n", + "task t;\n" + " `uvm_error(foo, bar)\n" + " ;\n" + "endtask\n"}, + {"task t;\n" + "if(expr)begin\t\n" + "`uvm_error(foo,bar);\n" + "end\n" + "endtask\n", + "task t;\n" + " if (expr) begin\n" + " `uvm_error(foo, bar);\n" + " end\n" + "endtask\n"}, + {"task\nrabbit;$kill(the,\nrabbit)\n;endtask: rabbit\n", + "task rabbit;\n" + " $kill(the, rabbit);\n" + "endtask : rabbit\n"}, + {"function int foo( );if( a )a+=1 ; endfunction", + "function int foo();\n" + " if (a) a += 1;\n" + "endfunction\n"}, + {"function void foo( );foo=`MACRO(b,c) ; endfunction", + "function void foo();\n" + " foo = `MACRO(b, c);\n" + "endfunction\n"}, + {"module foo;if \t (bar)begin assign a=1; end endmodule", + "module foo;\n" + " if (bar) begin\n" + " assign a = 1;\n" + " end\n" + "endmodule\n"}, + {"module proc_cont_assigner;\n" + "always begin\n" + "assign x1 = y1;\n" + "deassign x2 ;\n" + "force x3=y3;\n" + "release x4 ;\n" + "end\n" + "endmodule\n", + "module proc_cont_assigner;\n" + " always begin\n" + " assign x1 = y1;\n" + " deassign x2;\n" + " force x3 = y3;\n" + " release x4;\n" + " end\n" + "endmodule\n"}, + {"module g_test( );\n" + "\tinitial begin:main_test \t" + "for(int i=0;i<k;i++)begin " + "case(i )\n" + " 6'd0 :release in[0]; \n" + " endcase " + " \t\tend \t" + "\t end:main_test\n" + "endmodule:g_test\n", + "module g_test ();\n" + " initial begin : main_test\n" + " for (int i = 0; i < k; i++) begin\n" + " case (i)\n" + " 6'd0: release in[0];\n" + " endcase\n" + " end\n" + " end : main_test\n" + "endmodule : g_test\n"}, + {// conditional generate (case) + "module mc; case(s)a : bb c ; d : ee f; endcase endmodule", + "module mc;\n" + " case (s)\n" + " a: bb c;\n" + " d: ee f;\n" + " endcase\n" + "endmodule\n"}, + {// conditional generate (case), with comments + "module mc; case(s)\n//comment a\na:bb c;\n//comment b\n endcase " + "endmodule", + "module mc;\n" + " case (s)\n" + " //comment a\n" // indented to case-item level + " a: bb c;\n" + " //comment b\n" // indented to case-item level + " endcase\n" + "endmodule\n"}, + + {// "default:", not "default :" + "function f; case (x) default: x=y; endcase endfunction\n", + "function f;\n" + " case (x)\n" + " default: x = y;\n" + " endcase\n" + "endfunction\n"}, + {// default with null statement: "default: ;", not "default :;" + "function f; case (x) default :; endcase endfunction\n", + "function f;\n" + " case (x)\n" + " default: ;\n" + " endcase\n" + "endfunction\n"}, + {// case statement + "function f; case (x) State0 : a=b; State1 : begin a=b; end " + "endcase endfunction\n", + "function f;\n" + " case (x)\n" + " State0: a = b;\n" + " State1: begin\n" + " a = b;\n" + " end\n" + " endcase\n" + "endfunction\n"}, + {// case statement, interleaved with comments + "function f; case (x) \n//c1\nState0 : a=b;//c2\n//c3\n State1 : " + "a=b;//c4\n//c5\n " + "endcase endfunction\n", + "function f;\n" + " case (x)\n" + " //c1\n" + " State0: a = b; //c2\n" + " //c3\n" + " State1: a = b; //c4\n" + " //c5\n" + " endcase\n" + "endfunction\n"}, + {// case inside statement, comments + "function f; case (x)inside \n//comment\n" + "[0:1]:x=y; \n" + " //comment\n" + "endcase endfunction\n", + "function f;\n" + " case (x) inside\n" + " //comment\n" + " [0 : 1]: x = y;\n" + " //comment\n" + " endcase\n" + "endfunction\n"}, + {// case inside statement + "function f; case (x)inside k1 : return b; k2 : begin return b; end " + "endcase endfunction\n", + "function f;\n" + " case (x) inside\n" + " k1: return b;\n" + " k2: begin\n" + " return b;\n" + " end\n" + " endcase\n" + "endfunction\n"}, + {// case inside statement, with ranges + "function f; case (x) inside[a:b] : return b; [c:d] : return b; " + "default :return z;" + "endcase endfunction\n", + "function f;\n" + " case (x) inside\n" + " [a : b]: return b;\n" + " [c : d]: return b;\n" + " default: return z;\n" + " endcase\n" + "endfunction\n"}, + {// case pattern statement + "function f;" + "case (y) matches " + ".foo : return 0;" + ".*\t: return 1;" + "endcase " + "case (z) matches " + ".foo\t\t: return 0;" + ".* : return 1;" + "endcase " + "endfunction", + "function f;\n" + " case (y) matches\n" + " .foo: return 0;\n" + " .*: return 1;\n" + " endcase\n" + " case (z) matches\n" + " .foo: return 0;\n" + " .*: return 1;\n" + " endcase\n" + "endfunction\n"}, + {// keep short case items on one line + "function f; case (x)k1 : if( b )break; default :return 2;" + "endcase endfunction\n", + "function f;\n" + " case (x)\n" + " k1: if (b) break;\n" // aligned + " default: return 2;\n" + " endcase\n" + "endfunction\n"}, + {// keep short default items on one line + "function f; case (x)k1 :break; default :if( c )return 2;" + "endcase endfunction\n", + "function f;\n" + " case (x)\n" + " k1: break;\n" // aligned + " default: if (c) return 2;\n" + " endcase\n" + "endfunction\n"}, + {// keep short case inside items on one line + "function f; case (x)inside k1 : if( b )return c; k2 : return a;" + "endcase endfunction\n", + "function f;\n" + " case (x) inside\n" + " k1: if (b) return c;\n" + " k2: return a;\n" + " endcase\n" + "endfunction\n"}, + {// keep short case pattern items on one line + "function f;" + "case (y) matches " + ".foo :if( n )return 0;" + ".*\t: return 1;" + "endcase " + "endfunction", + "function f;\n" + " case (y) matches\n" + " .foo: if (n) return 0;\n" + " .*: return 1;\n" + " endcase\n" + "endfunction\n"}, + {// randcase + "function f; randcase k1 : return c; k2 : return a;" + "endcase endfunction\n", + "function f;\n" + " randcase\n" + " k1: return c;\n" + " k2: return a;\n" + " endcase\n" + "endfunction\n"}, + + // This tests checks for not breaking around hierarchy operators. + {"function\nvoid\twarranty;" + "foo.bar = fancyfunction(aaaaaaaa.bbbbbbb," + " ccccccccc.ddddddddd) ;" + "endfunction :warranty\n", + "function void warranty;\n" + " foo.bar = fancyfunction(\n" + " aaaaaaaa.bbbbbbb,\n" + " ccccccccc.ddddddddd\n" + " );\n" + "endfunction : warranty\n"}, + + // Group of tests testing partitioning of arguments inside function calls + {// function with function call inside if statement header + "function foo;if(aa(bb,cc));endfunction\n", + "function foo;\n" + " if (aa(bb, cc));\n" + "endfunction\n"}, + {// function with function call inside if statement header and with + // begin-end block + "function foo;if (aa(bb,cc,dd,ee))begin end endfunction\n", + "function foo;\n" + " if (aa(bb, cc, dd, ee)) begin\n" + " end\n" + "endfunction\n"}, + {// function with kMethodCallExtension inside if statement header and with + // begin-end block + "function foo;if (aa.bb(cc,dd,ee))begin end endfunction\n", + "function foo;\n" + " if (aa.bb(cc, dd, ee)) begin\n" + " end\n" + "endfunction\n"}, + {// nested kMethodCallExtension calls - one level + "function foo;aa.bb(cc.dd(a1), ee.ff(a2));endfunction\n", + "function foo;\n" + " aa.bb(cc.dd(a1), ee.ff(a2));\n" + "endfunction\n"}, + {// nested kMethodCallExtension calls - two level + "function foo;aa.bb(cc.dd(a1.b1(a2), b1), ee.ff(c1, d1));endfunction\n", + "function foo;\n" + " aa.bb(cc.dd(a1.b1(a2), b1), ee.ff(\n" + " c1, d1));\n" + "endfunction\n"}, + + {// simple initial statement with function call + "module m;initial aa(bb,cc,dd,ee);endmodule\n", + "module m;\n" + " initial aa(bb, cc, dd, ee);\n" + "endmodule\n"}, + {// expressions and function calls inside if-statement headers + "module m;initial begin if(aa(bb)==cc(dd))a=b;if (xx()) b = a;end " + "endmodule\n", + "module m;\n" + " initial begin\n" + " if (aa(bb) == cc(dd)) a = b;\n" + " if (xx()) b = a;\n" + " end\n" + "endmodule\n"}, + {// fuction with two arguments inside if-statement headers + "module\nm;initial\nbegin\nif(aa(bb,cc))x=y;end\nendmodule\n", + "module m;\n" + " initial begin\n" + " if (aa(bb, cc)) x = y;\n" + " end\n" + "endmodule\n"}, + {// kMethodCallExtension inside if-statement headers + "module m;initial begin if (aa.bb(cc)) x = y;end endmodule", + "module m;\n" + " initial begin\n" + " if (aa.bb(cc)) x = y;\n" + " end\n" + "endmodule\n"}, + {// initial statement with object method call + "module m; initial a.b(a,b,c); endmodule\n", + "module m;\n" + " initial a.b(a, b, c);\n" + "endmodule\n"}, + {// initial statement with method call on indexed object + "module m; initial a[i].b(a,b,c); endmodule\n", + "module m;\n" + " initial a[i].b(a, b, c);\n" + "endmodule\n"}, + {// initial statement with method call on function returned object + "module m; initial a(d,e,f).b(a,b,c); endmodule\n", + "module m;\n" + " initial a(d, e, f).b(a, b, c);\n" + "endmodule\n"}, + {// initial statement with indexed access to function returned object + "module m; initial a(a,b,c)[i]; endmodule\n", + "module m;\n" + " initial a(a, b, c) [i];\n" + "endmodule\n"}, + {// method call with no arguments on an object + "module m; initial foo.bar();endmodule\n", + "module m;\n" + " initial foo.bar();\n" + "endmodule\n"}, + {// method call with one argument on an object + "module m; initial foo.bar(aa);endmodule\n", + "module m;\n" + " initial foo.bar(aa);\n" + "endmodule\n"}, + {// method call with two arguments on an object + "module m; initial foo.bar(aa,bb);endmodule\n", + "module m;\n" + " initial foo.bar(aa, bb);\n" + "endmodule\n"}, + {// method call with three arguments on an object + "module m; initial foo.bar(aa,bb,cc);endmodule\n", + "module m;\n" + " initial foo.bar(aa, bb, cc);\n" + "endmodule\n"}, + + { + // This tests for if-statements with null statements + "function foo;" + "if (zz) ; " + "if (yy) ; " + "endfunction", + "function foo;\n" + " if (zz);\n" + " if (yy);\n" + "endfunction\n", + }, + + { + // This tests for if-statements starting on their own line. + "function foo;" + "if (zz) begin " + "return 0;" + "end " + "if (yy) begin " + "return 1;" + "end " + "endfunction", + "function foo;\n" + " if (zz) begin\n" + " return 0;\n" + " end\n" + " if (yy) begin\n" + " return 1;\n" + " end\n" + "endfunction\n", + }, + + { + // This tests for if-statements with single statement bodies + "function foo;" + "if (zz) return 0;" + "if (yy) return 1;" + "endfunction", + "function foo;\n" + " if (zz) return 0;\n" + " if (yy) return 1;\n" + "endfunction\n", + }, + + { + // This tests for if-statement mixed with plain statements + "function foo;" + "a=b;" + "if (zz) return 0;" + "c=d;" + "endfunction", + "function foo;\n" + " a = b;\n" + " if (zz) return 0;\n" + " c = d;\n" + "endfunction\n", + }, + + { + // This tests for if-statement with forced break mixed with others + "function foo;" + "a=b;" + "if (zz)//\n return 0;" + "c=d;" + "endfunction", + "function foo;\n" + " a = b;\n" + " if (zz) //\n" + " return 0;\n" + " c = d;\n" + "endfunction\n", + }, + { + "function t;" + "if (r == t)" + "a.b(c);" + "endfunction", + "function t;\n" + " if (r == t) a.b(c);\n" + "endfunction\n", + }, + + {// This tests for for-statement with forced break mixed with others + "function f;" + "x=y;" + "for (int i=0; i<S*IPS; i++) #1ps a += $urandom();" + "return 2;" + "endfunction", + "function f;\n" + " x = y;\n" + " for (int i = 0; i < S * IPS; i++)\n" // doesn't fit, so indents + " #1ps a += $urandom();\n" + " return 2;\n" + "endfunction\n"}, + + { + // This tests for-statements with null statements + "function foo;" + "for(;;) ;\t" + "for(;;) ;\t" + "endfunction", + "function foo;\n" + " for (;;);\n" + " for (;;);\n" + "endfunction\n", + }, + + { + // This tests for if-else-statements with null statements + "function foo;" + "if (zz) ; else ;" + "if (yy) ; else ;" + "endfunction", + "function foo;\n" + " if (zz);\n" + " else;\n" + " if (yy);\n" + " else;\n" + "endfunction\n", + }, + + { + // This tests for end-else-begin. + "function foo;" + "if (zz) begin " + "return 0;" + "end " + "else " + "begin " + "return 1;" + "end " + "endfunction", + "function foo;\n" + " if (zz) begin\n" + " return 0;\n" + " end else begin\n" + " return 1;\n" + " end\n" + "endfunction\n", + }, + { + // This tests for end-else-if + "function foo;" + "if (zz) begin " + "return 0;" + "end " + "else " + "if(yy)begin " + "return 1;" + "end " + "endfunction", + "function foo;\n" + " if (zz) begin\n" + " return 0;\n" + " end else if (yy) begin\n" + " return 1;\n" + " end\n" + "endfunction\n", + }, + { + // This tests labeled end-else-if + "function foo;" + "if (zz) begin : label1 " + "return 0;" + "end : label1 " + "else if (yy) begin : label2 " + "return 1;" + "end : label2 " + "endfunction", + "function foo;\n" + " if (zz) begin : label1\n" + " return 0;\n" + " end : label1\n" + " else if (yy) begin : label2\n" + " return 1;\n" + " end : label2\n" + "endfunction\n", + }, + { + // This tests labeled end-else-if-else + "function foo;" + "if (zz) begin : label1 " + "return 0;" + "end : label1 " + "else if (yy) begin : label2 " + "return 1;" + "end : label2 " + "else begin : label3 " + "return 2;" + "end : label3 " + "endfunction", + "function foo;\n" + " if (zz) begin : label1\n" + " return 0;\n" + " end : label1\n" + " else if (yy) begin : label2\n" + " return 1;\n" + " end : label2\n" + " else begin : label3\n" + " return 2;\n" + " end : label3\n" + "endfunction\n", + }, + + { + // randomize function + "function r ;" + "if ( ! randomize (bar )) begin end " + "if ( ! obj.randomize (bar )) begin end " + "endfunction", + "function r;\n" + " if (!randomize(bar)) begin\n" + " end\n" + " if (!obj.randomize(bar)) begin\n" + " end\n" + "endfunction\n", + }, + { + // randomize-with call, with comments + "function f;" + "s = std::randomize() with {\n" + "// comment1\n" + "a == e;\n" + "// comment2\n" + "};" + "endfunction\n", + "function f;\n" + " s = std::randomize() with {\n" + " // comment1\n" + " a == e;\n" + " // comment2\n" + " };\n" + "endfunction\n", + }, + { + // randomize-with call, with comments, one joined + "function f;" + "s = std::randomize() with {\n" + "// comment1\n" + "a == e;// comment2\n" + "};" + "endfunction\n", + "function f;\n" + " s = std::randomize() with {\n" + " // comment1\n" + " a == e; // comment2\n" + " };\n" + "endfunction\n", + }, + { + // randomize-with call, with comment, and conditional + "function f;" + "s = std::randomize() with {\n" + "// comment\n" + "a == e;" + "if (x) {" + "a;" + "}" + "};" + "endfunction\n", + "function f;\n" + " s = std::randomize() with {\n" + " // comment\n" + " a == e;\n" + " if (x) {a;}\n" // TODO(fangism): consider expanding + " };\n" + "endfunction\n", + }, + + // module declaration test cases + {" module foo ; endmodule\n", + "module foo;\n" + "endmodule\n"}, + {" module foo ( ) ; endmodule\n", + "module foo ();\n" + "endmodule\n"}, + {" module foo ( .x ( x) ); endmodule\n", + "module foo (\n" + " .x(x)\n" + ");\n" + "endmodule\n"}, + {" module foo ( .x ( x) \n,\n . y " + " ( \ny) ); endmodule\n", + "module foo (\n" + " .x(x),\n" + " .y(y)\n" + ");\n" + "endmodule\n"}, + + // module instantiation test cases + {" module foo ; bar bq();endmodule\n", + "module foo;\n" + " bar bq ();\n" // single instance + "endmodule\n"}, + {" module foo ; bar bq(), bq2( );endmodule\n", + "module foo;\n" + " bar bq (), bq2 ();\n" // multiple instances, still fitting on one line + "endmodule\n"}, + {"module foo; bar #(.N(N)) bq (.bus(bus));endmodule\n", + // instance parameter and port fits on line + "module foo;\n" + " bar #(.N(N)) bq (.bus(bus));\n" + "endmodule\n"}, + {"module foo; bar #(.N(N),.M(M)) bq ();endmodule\n", // two named params + "module foo;\n" + " bar #(\n" + " .N(N),\n" + " .M(M)\n" + " ) bq ();\n" + "endmodule\n"}, + {"module foo; bar #(//comment\n.N(N),.M(M)) bq ();endmodule\n", + "module foo;\n" + " bar #( //comment\n" // EOL comment before first param + " .N(N),\n" + " .M(M)\n" + " ) bq ();\n" + "endmodule\n"}, + {"module foo; bar #(.N(N),//comment\n.M(M)) bq ();endmodule\n", + "module foo;\n" + " bar #(\n" + " .N(N), //comment\n" // EOL comment after first param + " .M(M)\n" + " ) bq ();\n" + "endmodule\n"}, + {"module foo; bar #(.N(N),.M(M)//comment\n) bq ();endmodule\n", + "module foo;\n" + " bar #(\n" + " .N(N),\n" + " .M(M) //comment\n" // EOL comment after last param + " ) bq ();\n" + "endmodule\n"}, + {" module foo ; bar bq(aa,bb,cc);endmodule\n", + "module foo;\n" + " bar bq (\n" + " aa,\n" + " bb,\n" + " cc\n" + " );\n" // multiple positional ports, one per line + "endmodule\n"}, + {" module foo ; bar bq(aa,\n" + "`ifdef BB\n" + "bb,\n" + "`endif\n" + "cc);endmodule\n", + "module foo;\n" + " bar bq (\n" + " aa,\n" + "`ifdef BB\n" + " bb,\n" // keep same indentation as outside conditional + "`endif\n" + " cc\n" + " );\n" // multiple positional ports, one per line + "endmodule\n"}, + {" module foo ; bar bq(.aa,.bb);endmodule\n", + "module foo;\n" + " bar bq (\n" + " .aa,\n" + " .bb\n" + " );\n" // multiple named ports, one per line + "endmodule\n"}, + {" module foo ; bar bq(.aa(aa),.bb(bb));endmodule\n", + "module foo;\n" + " bar bq (\n" + " .aa(aa),\n" + " .bb(bb)\n" + " );\n" // multiple named ports, one per line + "endmodule\n"}, + {" module foo ; bar bq(.aa(aa),\n" + "`ifdef ZZ\n" + ".zz( zz ),\n" + "`else\n" + ".yy( yy ),\n" + "`endif\n" + ".bb(bb)\n" + ");endmodule\n", + "module foo;\n" + " bar bq (\n" + " .aa(aa),\n" + "`ifdef ZZ\n" + " .zz(zz),\n" + "`else\n" + " .yy(yy),\n" + "`endif\n" + " .bb(bb)\n" + " );\n" // multiple named ports, one per line + "endmodule\n"}, + {" module foo ; bar#(NNNNNNNN)" + "bq(.aa(aaaaaa),.bb(bbbbbb));endmodule\n", + "module foo;\n" + " bar #(NNNNNNNN) bq (\n" + " .aa(aaaaaa),\n" + " .bb(bbbbbb)\n" + " );\n" + "endmodule\n"}, + {" module foo ; barrrrrrr " + "bq(.aaaaaa(aaaaaa),.bbbbbb(bbbbbb));endmodule\n", + "module foo;\n" + " barrrrrrr bq (\n" + " .aaaaaa(aaaaaa),\n" + " .bbbbbb(bbbbbb)\n" + " );\n" + "endmodule\n"}, + {"module foo; bar #(.NNNNN(NNNNN)) bq (.bussss(bussss));endmodule\n", + // instance parameter and port does not fit on line + "module foo;\n" + " bar #(\n" + " .NNNNN(NNNNN)\n" + " ) bq (\n" + " .bussss(bussss)\n" + " );\n" + "endmodule\n"}, + {"module foo; bar #(//\n.N(N)) bq (.bus(bus));endmodule\n", + "module foo;\n" + " bar #( //\n" // would fit on one line, but forced to expand by // + " .N(N)\n" + " ) bq (\n" + " .bus(bus)\n" + " );\n" + "endmodule\n"}, + {"module foo; bar #(\n" + "`ifdef MM\n" + ".M(M)\n" + "`else\n" + ".N(N)\n" + "`endif\n" + ") bq (.bus(bus));endmodule\n", + "module foo;\n" + " bar #(\n" + "`ifdef MM\n" + " .M(M)\n" + "`else\n" + " .N(N)\n" + "`endif\n" + " ) bq (\n" + " .bus(bus)\n" + " );\n" + "endmodule\n"}, + {"module foo; bar #(.N(N)//\n) bq (.bus(bus));endmodule\n", + "module foo;\n" + " bar #(\n" // would fit on one line, but forced to expand by // + " .N(N) //\n" + " ) bq (\n" + " .bus(bus)\n" + " );\n" + "endmodule\n"}, + {"module foo; bar #(.N(N)) bq (//\n.bus(bus));endmodule\n", + "module foo;\n" + " bar #(\n" // would fit on one line, but forced to expand by // + " .N(N)\n" + " ) bq ( //\n" + " .bus(bus)\n" + " );\n" + "endmodule\n"}, + {"module foo; bar #(.N(N)) bq (.bus(bus)//\n);endmodule\n", + "module foo;\n" + " bar #(\n" // would fit on one line, but forced to expand by // + " .N(N)\n" + " ) bq (\n" + " .bus(bus) //\n" + " );\n" + "endmodule\n"}, + {" module foo ; bar " + "bq(.aaa(aaa),.bbb(bbb),.ccc(ccc),.ddd(ddd));endmodule\n", + "module foo;\n" + " bar bq (\n" + " .aaa(aaa),\n" // ports don't fit on one line, so expanded + " .bbb(bbb),\n" + " .ccc(ccc),\n" + " .ddd(ddd)\n" + " );\n" + "endmodule\n"}, + {" module foo ; bar " + "bq(.aa(aa),.bb(bb),.cc(cc),.dd(dd));endmodule\n", + "module foo;\n" + " bar bq (\n" + " .aa(aa),\n" // one named port per line + " .bb(bb),\n" + " .cc(cc),\n" + " .dd(dd)\n" + " );\n" + "endmodule\n"}, + {" module foo ; bar " + "bq(.aa(aa),//\n.bb(bb),.cc(cc),.dd(dd));endmodule\n", + "module foo;\n" + " bar bq (\n" + " .aa(aa), //\n" // forced to expand by // + " .bb(bb),\n" + " .cc(cc),\n" + " .dd(dd)\n" + " );\n" + "endmodule\n"}, + {" module foo ; bar " + "bq(.aa(aa),.bb(bb),.cc(cc),.dd(dd)//\n);endmodule\n", + "module foo;\n" + " bar bq (\n" + " .aa(aa),\n" + " .bb(bb),\n" + " .cc(cc),\n" + " .dd(dd) //\n" // forced to expand by // + " );\n" + "endmodule\n"}, + {// gate instantiation test + "module m;" + "and\tx0(a, \t\tb,c);" + "or\nx1(a, \n b, d);" + "endmodule\n", + "module m;\n" + " and x0 (a, b, c);\n" + " or x1 (a, b, d);\n" + "endmodule\n"}, + {// ifdef inside port actuals + "module m; foo bar (\n" + "`ifdef BAZ\n" + "`endif\n" + ") ;endmodule\n", + "module m;\n" + " foo bar (\n" + "`ifdef BAZ\n" + "`endif\n" + " );\n" + "endmodule\n"}, + {// ifdef inside port actuals after a port connection + "module m; foo bar ( .a (a) ,\n" + "`ifdef BAZ\n" + "`endif\n" + ") ;endmodule\n", + "module m;\n" + " foo bar (\n" + " .a(a),\n" + "`ifdef BAZ\n" + "`endif\n" + " );\n" + "endmodule\n"}, + {// ifdef inside port actuals before a port connection + "module m; foo bar (\n" + "`ifdef BAZ\n" + "`endif\n" + ". b(b) ) ;endmodule\n", + "module m;\n" + " foo bar (\n" + "`ifdef BAZ\n" + "`endif\n" + " .b(b)\n" + " );\n" + "endmodule\n"}, + {// ifdef-conditional port connection + "module m; foo bar (\n" + "`ifdef BAZ\n" + ". c (\tc) \n" + "`endif\n" + " ) ;endmodule\n", + "module m;\n" + " foo bar (\n" + "`ifdef BAZ\n" + " .c(c)\n" + "`endif\n" + " );\n" + "endmodule\n"}, + {// ifndef-else-conditional port connection + "module m; foo bar (\n" + "`ifndef BAZ\n" + ". c (\tc) \n" + " `else\n" + " . d(d\t)\n" + " `endif\n" + " ) ;endmodule\n", + "module m;\n" + " foo bar (\n" + "`ifndef BAZ\n" + " .c(c)\n" + "`else\n" + " .d(d)\n" + "`endif\n" + " );\n" + "endmodule\n"}, + + {// comment following a delay in next line + "module t;\n" + "reg x;\n" + "initial begin\n" + "#20\n" + "//comment\n" + "x = 1;\n" + "x = 2;\n" + "end\n" + "endmodule\n", + "module t;\n" + " reg x;\n" + " initial begin\n" + " #20\n" + " //comment\n" + " x = 1;\n" + " x = 2;\n" + " end\n" + "endmodule\n"}, + {// comment following a delay in the same line + "module t;\n" + "reg x;\n" + "initial begin\n" + "#20 //comment\n" + "x = 1;\n" + "x = 2;\n" + "end\n" + "endmodule\n", + "module t;\n" + " reg x;\n" + " initial begin\n" + " #20 //comment\n" + " x = 1;\n" + " x = 2;\n" + " end\n" + "endmodule\n"}, + // Macro calls inside [...] + {"module foo;\nlogic [`BAR(1)\n+2] foo;\nendmodule", + "module foo;\n" + " logic [`BAR(1)\n" + "+2] foo;\n" + "endmodule\n"}, + {"module foo;\nlogic [`BAR(1)+2] foo;\nendmodule", + "module foo;\n" + " logic [`BAR(1)+2] foo;\n" + "endmodule\n"}, + {"module foo ();\n function bar();\n " + "logic [12:34] data[`AAAAAAAAAAAAAAAAAAAAAAAA(1) : " + "`BBBBBBBBBBBBBBBBBBBBBBBB(2) + 3];\n " + "endfunction\nendmodule", + "module foo ();\n" + " function bar();\n" + " logic [12:34] data[\n" + " `AAAAAAAAAAAAAAAAAAAAAAAA(1) :\n" + " `BBBBBBBBBBBBBBBBBBBBBBBB(2) + 3];\n" + " endfunction\n" + "endmodule\n"}, + { + // test that alternate top-syntax mode works + "// verilog_syntax: parse-as-module-body\n" + "`define FOO\n", + "// verilog_syntax: parse-as-module-body\n" + "`define FOO\n", + }, + { + // test alternate parsing mode in macro expansion + "class foo;\n" + "`MY_MACRO(\n" + " // verilog_syntax: parse-as-statements\n" + " // EOL comment\n" + " int count;\n" + " if(cfg.enable) begin\n" + " count = 1;\n" + " end,\n" + " utils_pkg::decrement())\n" + "endclass\n", + "class foo;\n" + " `MY_MACRO(\n" + " // verilog_syntax: parse-as-statements\n" + " // EOL comment\n" + " int count;\n" + " if (cfg.enable) begin\n" + " count = 1;\n" + " end, utils_pkg::decrement())\n" + "endclass\n", + }, + + // tests top-level data declarations + {"a;", // implicit type + "a;\n"}, + {"a\tb;", // explicit type + "a b;\n"}, + {"a;b;", + "a;\n" + "b;\n"}, + {"a ,b;", // implicit type + "a, b;\n"}, + /* TODO(b/149591599): implicit type data declarations in module body + {"module\tm ;a ;endmodule", + "module m;\n" + " a;\n" + "endmodule\n"}, + */ + {"package\tp ;a ;endpackage", // implicit type + "package p;\n" + " a;\n" + "endpackage\n"}, + {"package\tp ;a ,b ;endpackage", // implicit type + "package p;\n" + " a, b;\n" + "endpackage\n"}, + {"package\tp ;a ;b ;endpackage", // implicit type + "package p;\n" + " a;\n" + " b;\n" + "endpackage\n"}, + /* TODO(b/149591627) : implicit type data declarations in class body + {"class\tc ;a ;endclass", + "class c;\n" + " a;\n" + "endclass\n"}, + */ + {"function\tf ;a ;endfunction", // implicit type + "function f;\n" + " a;\n" + "endfunction\n"}, + {"function\tf ;a ;x ;endfunction", // implicit type + "function f;\n" + " a;\n" + " x;\n" + "endfunction\n"}, + /* TODO(b/149592527): multi-variable data declaration as block_item_decl + // same inside tasks + {"function\tf ;a \t,x ;endfunction", // implicit type + "function f;\n" + " a, x;\n" + "endfunction\n"}, + */ + {"task\tt ;a ;endtask", // implicit type + "task t;\n" + " a;\n" + "endtask\n"}, + {"task\tt ;a ;x ;endtask", // implicit type + "task t;\n" + " a;\n" + " x;\n" + "endtask\n"}, + + {// tests bind declaration + "bind foo bar baz ( . clk ( clk ) ) ;", + "bind foo bar baz (.clk(clk));\n"}, + {// tests bind declaration, with type params + "bind foo bar# ( . W ( W ) ) baz ( . clk ( clk ) ) ;", + "bind foo bar #(.W(W)) baz (.clk(clk));\n"}, + {// tests bind declarations + "bind foo bar baz ( ) ;" + "bind goo car caz ( );", + "bind foo bar baz ();\n" + "bind goo car caz ();\n"}, + + {"bind blah foo #( .MaxCount(MaxCount), .MaxDelta(MaxDelta)) bar (" + " .clk(clk), .rst(rst), .value(value) );", + "bind blah foo #(\n" + " .MaxCount(MaxCount),\n" + " .MaxDelta(MaxDelta)\n" + ") bar (\n" + " .clk (clk),\n" + " .rst (rst),\n" + " .value(value)\n" + ");\n"}, + {"bind foo bar baz(\\\n" + "`undef d\\\n" + "`undef d);", + "bind foo bar baz (\\\n" + " `undef d\\\n" + " `undef d\n" + ");\n"}, + { + "bind expaaaaaaaaaaand_meeee looooooooong_name# (" + ".W(W_CONST), .H(H_CONST), .D(D_CONST) )" + "instaaance_name (.in(iiiiiiiin), .out(ooooooout), .clk(ccccccclk));", + "bind expaaaaaaaaaaand_meeee\n" + " looooooooong_name #(\n" + " .W(W_CONST),\n" + " .H(H_CONST),\n" + " .D(D_CONST)\n" + ") instaaance_name (\n" + " .in (iiiiiiiin),\n" + " .out(ooooooout),\n" + " .clk(ccccccclk)\n" + ");\n", + }, + + { + "bind expand_inst name# (" + ".W(W_CONST), .H(H_CONST), .D(D_CONST) )" + "instaaance_name (.in(iiiiiiiin), .out(ooooooout), .clk(ccccccclk));", + "bind expand_inst name #(\n" + " .W(W_CONST),\n" + " .H(H_CONST),\n" + " .D(D_CONST)\n" + ") instaaance_name (\n" + " .in (iiiiiiiin),\n" + " .out(ooooooout),\n" + " .clk(ccccccclk)\n" + ");\n", + }, + + { + // tests import declaration + "import foo_pkg :: bar ;", + "import foo_pkg::bar;\n", + }, + { + // tests import declaration with wildcard + "import foo_pkg :: * ;", + "import foo_pkg::*;\n", + }, + { + // tests import declarations + "import foo_pkg :: *\t;" + "import goo_pkg\n:: thing ;", + "import foo_pkg::*;\n" + "import goo_pkg::thing;\n", + }, + // preserve spaces inside [] dimensions, but limit spaces around ':' to one + // and adjust everything else + {"foo[W-1:0]a[0:K-1];", // data declaration + "foo [W-1:0] a[0:K-1];\n"}, + {"foo[W-1 : 0]a[0 : K-1];", "foo [W-1 : 0] a[0 : K-1];\n"}, + {"foo[W - 1 : 0 ]a [ 0 : K - 1] ;", + "foo [W - 1 : 0] a[0 : K - 1];\n"}, + // remove spaces between [...] [...] in multi-dimension arrays + {"foo[K] [W]a;", // + "foo [K][W] a;\n"}, + {"foo b [K] [W] ;", // + "foo b[K][W];\n"}, + {"logic[K:1] [W:1]a;", // + "logic [K:1][W:1] a;\n"}, + {"logic b [K:1] [W:1] ;", // + "logic b[K:1][W:1];\n"}, + // spaces in bit slicing + { + // preserve 0 spaces + "always_ff @(posedge clk) begin " + "dummy <=\tfoo [ 7:2 ] ; " + "end", + "always_ff @(posedge clk) begin\n" + " dummy <= foo[7:2];\n" + "end\n", + }, + { + // preserve 1 space + "always_ff @(posedge clk) begin " + "dummy <=\tfoo [ 7 : 2 ] ; " + "end", + "always_ff @(posedge clk) begin\n" + " dummy <= foo[7 : 2];\n" + "end\n", + }, + { + // limit multiple spaces to 1 + "always_ff @(posedge clk) begin " + "dummy <=\tfoo [ 7 : 2 ] ; " + "end", + "always_ff @(posedge clk) begin\n" + " dummy <= foo[7 : 2];\n" + "end\n", + }, + { + "always_ff @(posedge clk) begin " + "dummy <=\tfoo [ 7 : 2 ] ; " + "end", + "always_ff @(posedge clk) begin\n" + " dummy <= foo[7 : 2];\n" + "end\n", + }, + { + // keep value on the left when symmetrizing + "always_ff @(posedge clk) begin " + "dummy <=\tfoo [ 7: 2 ] ; " + "end", + "always_ff @(posedge clk) begin\n" + " dummy <= foo[7:2];\n" + "end\n", + }, + { + "always_ff @(posedge clk) begin " + "dummy <=\tfoo [ 7: 2 ] ; " + "end", + "always_ff @(posedge clk) begin\n" + " dummy <= foo[7:2];\n" + "end\n", + }, + { + "always_ff @(posedge clk) begin " + "dummy <=\tfoo [ 7 :2 ] ; " + "end", + "always_ff @(posedge clk) begin\n" + " dummy <= foo[7 : 2];\n" + "end\n", + }, + { + "always_ff @(posedge clk) begin " + "dummy <=\tfoo [ 7 : 2 ] ; " + "end", + "always_ff @(posedge clk) begin\n" + " dummy <= foo[7 : 2];\n" + "end\n", + }, + { + // use value on the left, but limit to 1 space + "always_ff @(posedge clk) begin " + "dummy <=\tfoo [ 7 :2 ] ; " + "end", + "always_ff @(posedge clk) begin\n" + " dummy <= foo[7 : 2];\n" + "end\n", + }, + + // task test cases + {"task t ;endtask:t", // + "task t;\n" + "endtask : t\n"}, + {"task t ;# 10 ;# 5ns ; # 0.1 ; # 1step ;endtask", + "task t;\n" + " #10;\n" // no space in delay expression + " #5ns;\n" + " #0.1;\n" + " #1step;\n" + "endtask\n"}, + {"task t\n;a<=b ;c<=d ;endtask\n", + "task t;\n" + " a <= b;\n" + " c <= d;\n" + "endtask\n"}, + {"class c; virtual protected task\tt ( foo bar);" + "a.a<=b.b;\t\tc.c\n<= d.d; endtask endclass", + "class c;\n" + " virtual protected task t(foo bar);\n" + " a.a <= b.b;\n" + " c.c <= d.d;\n" + " endtask\n" + "endclass\n"}, + {"task t;\n// statement comment\nendtask\n", + "task t;\n" + " // statement comment\n" // indented + "endtask\n"}, + {"task t( );\n// statement comment\nendtask\n", + "task t();\n" + " // statement comment\n" // indented + "endtask\n"}, + {"task t( input x );\n" + "// statement comment\n" + "s();\n" + "// statement comment\n" + "endtask\n", + "task t(input x);\n" + " // statement comment\n" // indented + " s();\n" + " // statement comment\n" // indented + "endtask\n"}, + {"task fj;fork join fork join\tendtask", + "task fj;\n" + " fork\n" + " join\n" + " fork\n" + " join\n" + "endtask\n"}, + {"task fj;fork join_any fork join_any\tendtask", + "task fj;\n" + " fork\n" + " join_any\n" + " fork\n" + " join_any\n" + "endtask\n"}, + {"task fj;fork join_none fork join_none\tendtask", + "task fj;\n" + " fork\n" + " join_none\n" + " fork\n" + " join_none\n" + "endtask\n"}, + {"task fj;fork\n" + "//c1\njoin\n" + "//c2\n" + "fork \n" + "//c3\n" + "join\tendtask", + "task fj;\n" + " fork\n" + " //c1\n" + " join\n" + " //c2\n" + " fork\n" + " //c3\n" + " join\n" + "endtask\n"}, + {"task fj;\n" + "fork " + "begin " + "end " + "foo();" + "begin " + "end " + "join_any endtask", + "task fj;\n" + " fork\n" + " begin\n" + " end\n" + " foo();\n" + " begin\n" + " end\n" + " join_any\n" + "endtask\n"}, + { + // call and assertion statements + "task t ;Fire() ;assert ( x);assert(y );endtask", + "task t;\n" + " Fire();\n" + " assert (x);\n" + " assert (y);\n" + "endtask\n", + }, + { + // assertion statements with body clause + "task t ;Fire() ;assert ( x) fee ( );assert(y ) foo ( ) ;endtask", + "task t;\n" + " Fire();\n" + " assert (x) fee();\n" + " assert (y) foo();\n" + "endtask\n", + }, + { + // assertion statements with else clause + "task t ;Fire() ;assert ( x) else fee ( );" + "assert(y ) else foo ( ) ;endtask", + "task t;\n" + " Fire();\n" + " assert (x)\n" + " else fee();\n" + " assert (y)\n" + " else foo();\n" + "endtask\n", + }, + { + // assertion statements with else clause + "task t ;Fire() ;assert ( x) fa(); else fee ( );" + "assert(y ) fi(); else foo ( ) ;endtask", + "task t;\n" + " Fire();\n" + " assert (x) fa();\n" + " else fee();\n" + " assert (y) fi();\n" + " else foo();\n" + "endtask\n", + }, + { + // assume statements + "task t ;Fire() ;assume ( x);assume(y );endtask", + "task t;\n" + " Fire();\n" + " assume (x);\n" + " assume (y);\n" + "endtask\n", + }, + { + // cover statements + "task t ;Fire() ;cover ( x);cover(y );endtask", + "task t;\n" + " Fire();\n" + " cover (x);\n" + " cover (y);\n" + "endtask\n", + }, + { + // cover statements, with action + "task t ;Fire() ;cover ( x)g( );cover(y ) h();endtask", + "task t;\n" + " Fire();\n" + " cover (x) g();\n" + " cover (y) h();\n" + "endtask\n", + }, + { + // cover statements, with action block + "task t ;Fire() ;cover ( x) begin g( ); end " + "cover(y ) begin h(); end endtask", + "task t;\n" + " Fire();\n" + " cover (x) begin\n" + " g();\n" + " end\n" + " cover (y) begin\n" + " h();\n" + " end\n" + "endtask\n", + }, + {// shuffle calls + "task t; foo. shuffle ( );bar .shuffle( ); endtask", + "task t;\n" + " foo.shuffle();\n" + " bar.shuffle();\n" + "endtask\n"}, + {// wait statements (null) + "task t; wait (a==b);wait(c<d); endtask", + "task t;\n" + " wait (a == b);\n" + " wait (c < d);\n" + "endtask\n"}, + {// wait statements, single action statement + "task t; wait (a==b) p();wait(c<d) q(); endtask", + "task t;\n" + " wait (a == b) p();\n" + " wait (c < d) q();\n" + "endtask\n"}, + {// wait statements, block action statement + "task t; wait (a==b) begin p(); end " + "wait(c<d) begin q(); end endtask", + "task t;\n" + " wait (a == b) begin\n" + " p();\n" + " end\n" + " wait (c < d) begin\n" + " q();\n" + " end\n" + "endtask\n"}, + {// wait fork statements + "task t ; wait\tfork;wait fork ;endtask", + "task t;\n" + " wait fork;\n" + " wait fork;\n" + "endtask\n"}, + {// labeled single statements (prefix-style) + "task t;l1:x<=y ;endtask", + "task t;\n" + " l1 : x <= y;\n" + "endtask\n"}, + {// labeled block statements (prefix-style) + "task t;l1:begin end:l1 endtask", + "task t;\n" + " l1 : begin\n" + " end : l1\n" + "endtask\n"}, + {// labeled seq block statements + "task t;begin:l1 end:l1 endtask", + "task t;\n" + " begin : l1\n" + " end : l1\n" + "endtask\n"}, + {// labeled par block statements + "task t;fork:l1 join:l1 endtask", + "task t;\n" + " fork : l1\n" + " join : l1\n" + "endtask\n"}, + {// task with disable statements + "task t ;fork\tjoin\tdisable\tfork;endtask", + "task t;\n" + " fork\n" + " join\n" + " disable fork;\n" + "endtask\n"}, + {"task t ;fork\tjoin_any\tdisable\tfork ;endtask", + "task t;\n" + " fork\n" + " join_any\n" + " disable fork;\n" + "endtask\n"}, + {"task t ;disable\tbean_counter ;endtask", + "task t;\n" + " disable bean_counter;\n" + "endtask\n"}, + { + // task with if-statement + "task t;" + "if (r == t)" + "a.b(c);" + "endtask", + "task t;\n" + " if (r == t) a.b(c);\n" + "endtask\n", + }, + { + // task with system call inside if header + "task t;" + "if (!$cast(ssssssssssssssss,vvvvvvvvvv,gggggggg))begin end endtask:t", + "task t;\n" + " if (!$cast(\n" + " ssssssssssssssss,\n" + " vvvvvvvvvv,\n" + " gggggggg\n" + " )) begin\n" + " end\n" + "endtask : t\n", + }, + { + // task with nested subtask call and arguments passed by name + "task t;" + "if (!$cast(ssssssssssssssss, vvvvvvvvvv.gggggggg(" + ".ppppppp(ppppppp)," + ".yyyyy(\"xxxxxxxxxxxxx\")" + "))) begin " + "end " + "endtask : t", + "task t;\n" + " if (!$cast(\n" + " ssssssssssssssss,\n" + " vvvvvvvvvv.gggggggg(\n" + " .ppppppp(ppppppp),\n" + " .yyyyy(\"xxxxxxxxxxxxx\")\n" + " )\n" + " )) begin\n" + " end\n" + "endtask : t\n", + }, + + { + // assert property statements + "task t ;assert property( x);assert\tproperty(y );endtask", + "task t;\n" + " assert property (x);\n" + " assert property (y);\n" + "endtask\n", + }, + { + // assert property statements, with action + "task t ;assert property( x) j();assert\tproperty(y )k( );endtask", + "task t;\n" + " assert property (x) j();\n" + " assert property (y) k();\n" + "endtask\n", + }, + { + // assert property statements, with action block + "task t ;assert property( x) begin j();end " + " assert\tproperty(y )begin\tk( ); end endtask", + "task t;\n" + " assert property (x) begin\n" + " j();\n" + " end\n" + " assert property (y) begin\n" + " k();\n" + " end\n" + "endtask\n", + }, + { + // assert property statements, else with null + "task t ;assert property( x) else;assert\tproperty(y )else;endtask", + "task t;\n" + " assert property (x)\n" + " else;\n" + " assert property (y)\n" + " else;\n" + "endtask\n", + }, + { + // assert property statements, else with actions + "task t ;assert property( x) f(); else p(); " + "\tassert\tproperty(y ) g();else q( );endtask", + "task t;\n" + " assert property (x) f();\n" + " else p();\n" + " assert property (y) g();\n" + " else q();\n" + "endtask\n", + }, + { + // assert property statement, with action block, else statement + "task t ;assert property( x) begin j();end else\tk( ); endtask", + "task t;\n" + " assert property (x) begin\n" + " j();\n" + " end else k();\n" + "endtask\n", + }, + { + // assert property statement, with action statement, else block + "task t ;assert property( x) j(); else begin\tk( );end endtask", + "task t;\n" + " assert property (x) j();\n" + " else begin\n" + " k();\n" + " end\n" + "endtask\n", + }, + { + // assert property statement, with action block, else block + "task t ;assert property( x)begin j();end " + "else begin\tk( );end endtask", + "task t;\n" + " assert property (x) begin\n" + " j();\n" + " end else begin\n" + " k();\n" + " end\n" + "endtask\n", + }, + + { + // assume property statements + "task t ;assume property( x);assume\tproperty(y );endtask", + "task t;\n" + " assume property (x);\n" + " assume property (y);\n" + "endtask\n", + }, + { + // assume property statements, with action + "task t ;assume property( x) j();assume\tproperty(y )k( );endtask", + "task t;\n" + " assume property (x) j();\n" + " assume property (y) k();\n" + "endtask\n", + }, + { + // assume property statements, with action block + "task t ;assume property( x) begin j();end " + " assume\tproperty(y )begin\tk( ); end endtask", + "task t;\n" + " assume property (x) begin\n" + " j();\n" + " end\n" + " assume property (y) begin\n" + " k();\n" + " end\n" + "endtask\n", + }, + { + // assume property statements, else with null + "task t ;assume property( x) else;assume\tproperty(y )else;endtask", + "task t;\n" + " assume property (x)\n" + " else;\n" + " assume property (y)\n" + " else;\n" + "endtask\n", + }, + { + // assume property statements, else with actions + "task t ;assume property( x) f(); else p(); " + "\tassume\tproperty(y ) g();else q( );endtask", + "task t;\n" + " assume property (x) f();\n" + " else p();\n" + " assume property (y) g();\n" + " else q();\n" + "endtask\n", + }, + { + // assume property statement, with action block, else statement + "task t ;assume property( x) begin j();end else\tk( ); endtask", + "task t;\n" + " assume property (x) begin\n" + " j();\n" + " end else k();\n" + "endtask\n", + }, + { + // assume property statement, with action statement, else block + "task t ;assume property( x) j(); else begin\tk( );end endtask", + "task t;\n" + " assume property (x) j();\n" + " else begin\n" + " k();\n" + " end\n" + "endtask\n", + }, + { + // assume property statement, with action block, else block + "task t ;assume property( x)begin j();end " + "else begin\tk( );end endtask", + "task t;\n" + " assume property (x) begin\n" + " j();\n" + " end else begin\n" + " k();\n" + " end\n" + "endtask\n", + }, + + { + // expect property statements + "task t ;expect ( x);expect\t(y );endtask", + "task t;\n" + " expect (x);\n" + " expect (y);\n" + "endtask\n", + }, + { + // expect property statements, with action + "task t ;expect ( x) j();expect\t(y )k( );endtask", + "task t;\n" + " expect (x) j();\n" + " expect (y) k();\n" + "endtask\n", + }, + { + // expect property statements, with action block + "task t ;expect ( x) begin j();end " + " expect\t(y )begin\tk( ); end endtask", + "task t;\n" + " expect (x) begin\n" + " j();\n" + " end\n" + " expect (y) begin\n" + " k();\n" + " end\n" + "endtask\n", + }, + { + // expect property statements, else with null + "task t ;expect ( x) else;expect\t(y )else;endtask", + "task t;\n" + " expect (x)\n" + " else;\n" + " expect (y)\n" + " else;\n" + "endtask\n", + }, + { + // expect property statements, else with actions + "task t ;expect ( x) f(); else p(); " + "\texpect\t(y ) g();else q( );endtask", + "task t;\n" + " expect (x) f();\n" + " else p();\n" + " expect (y) g();\n" + " else q();\n" + "endtask\n", + }, + { + // expect property statement, with action block, else statement + "task t ;expect ( x) begin j();end else\tk( ); endtask", + "task t;\n" + " expect (x) begin\n" + " j();\n" + " end else k();\n" + "endtask\n", + }, + { + // expect property statement, with action statement, else block + "task t ;expect ( x) j(); else begin\tk( );end endtask", + "task t;\n" + " expect (x) j();\n" + " else begin\n" + " k();\n" + " end\n" + "endtask\n", + }, + { + // expect property statement, with action block, else block + "task t ;expect ( x)begin j();end " + "else begin\tk( );end endtask", + "task t;\n" + " expect (x) begin\n" + " j();\n" + " end else begin\n" + " k();\n" + " end\n" + "endtask\n", + }, + + { + // cover property statements + "task t ;cover property( x);cover\tproperty(y );endtask", + "task t;\n" + " cover property (x);\n" + " cover property (y);\n" + "endtask\n", + }, + { + // cover property statements, with action + "task t ;cover property( x) j();cover\tproperty(y )k( );endtask", + "task t;\n" + " cover property (x) j();\n" + " cover property (y) k();\n" + "endtask\n", + }, + { + // cover property statements, with action block + "task t ;cover property( x) begin j();end " + " cover\tproperty(y )begin\tk( ); end endtask", + "task t;\n" + " cover property (x) begin\n" + " j();\n" + " end\n" + " cover property (y) begin\n" + " k();\n" + " end\n" + "endtask\n", + }, + + { + // cover sequence statements + "task t ;cover sequence( x);cover\tsequence(y );endtask", + "task t;\n" + " cover sequence (x);\n" + " cover sequence (y);\n" + "endtask\n", + }, + { + // cover sequence statements, with action + "task t ;cover sequence( x) j();cover\tsequence(y )k( );endtask", + "task t;\n" + " cover sequence (x) j();\n" + " cover sequence (y) k();\n" + "endtask\n", + }, + { + // cover sequence statements, with action block + "task t ;cover sequence( x) begin j();end " + " cover\tsequence(y )begin\tk( ); end endtask", + "task t;\n" + " cover sequence (x) begin\n" + " j();\n" + " end\n" + " cover sequence (y) begin\n" + " k();\n" + " end\n" + "endtask\n", + }, + + {// module with disable statements + "module m;always begin :block disable m.block; end endmodule", + "module m;\n" + " always begin : block\n" + " disable m.block;\n" + " end\n" + "endmodule\n"}, + {"module m;always begin disable m.block; end endmodule", + "module m;\n" + " always begin\n" + " disable m.block;\n" + " end\n" + "endmodule\n"}, + + // property test cases + {"module mp ;property p1 ; a|->b;endproperty endmodule", + "module mp;\n" + " property p1;\n" + " a |-> b;\n" + " endproperty\n" + "endmodule\n"}, + {"module mp ;property p1 ; a|->b;endproperty:p1 endmodule", + "module mp;\n" + " property p1;\n" + " a |-> b;\n" + " endproperty : p1\n" // with end label + "endmodule\n"}, + {"module mp ;property p1 ; a|->## 1 b;endproperty endmodule", + "module mp;\n" + " property p1;\n" + " a |-> ##1 b;\n" // with delay + " endproperty\n" + "endmodule\n"}, + {"module mp ;property p1 ; a|->## [0: 1] b;endproperty endmodule", + "module mp;\n" + " property p1;\n" + " a |-> ##[0:1] b;\n" // prefer no spaces with delay range + " endproperty\n" + "endmodule\n"}, + {"module mp ;property p1 ; a|->## [0 : 1] b;endproperty endmodule", + "module mp;\n" + " property p1;\n" + " a |-> ##[0 : 1] b;\n" // limit to one space, symmetrize + " endproperty\n" + "endmodule\n"}, + {"module mp ;property p1 ; a## 1 b;endproperty endmodule", + "module mp;\n" + " property p1;\n" + " a ##1 b;\n" + " endproperty\n" + "endmodule\n"}, + {"module mp ;property p1 ; (a^c)## 1 b;endproperty endmodule", + "module mp;\n" + " property p1;\n" + " (a ^ c) ##1 b;\n" + " endproperty\n" + "endmodule\n"}, + + // covergroup test cases + {// Minimal case + "covergroup c; endgroup\n", + "covergroup c;\n" + "endgroup\n"}, + {// Minimal useful case + "covergroup c @ (posedge clk); coverpoint a; endgroup\n", + "covergroup c @(posedge clk);\n" + " coverpoint a;\n" + "endgroup\n"}, + {// Multiple coverpoints + "covergroup foo @(posedge clk); coverpoint a; coverpoint b; " + "coverpoint c; coverpoint d; endgroup\n", + "covergroup foo @(posedge clk);\n" + " coverpoint a;\n" + " coverpoint b;\n" + " coverpoint c;\n" + " coverpoint d;\n" + "endgroup\n"}, + {// Multiple bins + "covergroup memory @ (posedge ce); address :coverpoint addr {" + "bins low={0,127}; bins high={128,255};} endgroup\n", + "covergroup memory @(posedge ce);\n" + " address: coverpoint addr {\n" + " bins low = {0, 127};\n" + " bins high = {128, 255};\n" + " }\n" + "endgroup\n"}, + {// Custom sample() function + "covergroup c with function sample(bit i); endgroup\n", + "covergroup c with function sample (\n" + " bit i\n" // test cases are wrapped at 40 + ");\n" + "endgroup\n"}, + +}; + +TEST(FormatterEndToEndTest, FunctionTaskFormatterTestCases) { + RunFormatterTestCases40(kFunctionTaskFormatterTestCases); +} + +} // namespace +} // namespace formatter +} // namespace verilog
diff --git a/verible/verilog/formatting/formatter_issue_regression_test.cc b/verible/verilog/formatting/formatter_issue_regression_test.cc new file mode 100644 index 0000000..8f1fcef --- /dev/null +++ b/verible/verilog/formatting/formatter_issue_regression_test.cc
@@ -0,0 +1,319 @@ +// Copyright 2017-2026 The Verible Authors. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Test cases in this file should be *insensitive* to wrapping penalties. +// Penalty-sensitive tests belong in formatter-tuning_test.cc. + +#include <sstream> +#include <string_view> + +#include "gmock/gmock.h" +#include "gtest/gtest.h" +#include "verible/common/util/logging.h" +#include "verible/verilog/formatting/format-style.h" +#include "verible/verilog/formatting/formatter-test-utils.h" +#include "verible/verilog/formatting/formatter.h" + +namespace verilog { +namespace formatter { +namespace { + +// Regression for https://github.com/chipsalliance/verible/issues/2547: +// A localparam initialized to a sum of long macros must converge: infix `+` +// stays with the following operand so re-format does not oscillate between +// `+\n`MACRO` and `+ `MACRO`. +TEST(FormatterEndToEndTest, LongMacroSumLocalparamConverges) { + static constexpr FormatterTestCase kTestCases[] = { + {"module m;\n" + " localparam N =\n" + " `MACRO_GEN3_SCRAMBLE_LFSR_REGOUT\n" + " + `MACRO_GEN3_SCRAMBLE_REGIN\n" + " + `MACRO_GEN3_SCRAMBLE_REGOUT\n" + " ;\n" + "endmodule\n", + "module m;\n" + " localparam N =\n" + " `MACRO_GEN3_SCRAMBLE_LFSR_REGOUT\n" + " + `MACRO_GEN3_SCRAMBLE_REGIN\n" + " + `MACRO_GEN3_SCRAMBLE_REGOUT;\n" + "endmodule\n"}, + // Already in pass-1 form must stay stable. + {"module m;\n" + " localparam N =\n" + " `MACRO_GEN3_SCRAMBLE_LFSR_REGOUT\n" + " + `MACRO_GEN3_SCRAMBLE_REGIN\n" + " + `MACRO_GEN3_SCRAMBLE_REGOUT;\n" + "endmodule\n", + "module m;\n" + " localparam N =\n" + " `MACRO_GEN3_SCRAMBLE_LFSR_REGOUT\n" + " + `MACRO_GEN3_SCRAMBLE_REGIN\n" + " + `MACRO_GEN3_SCRAMBLE_REGOUT;\n" + "endmodule\n"}, + }; + FormatStyle style; // default column_limit (100) + for (const auto &test_case : kTestCases) { + VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; + std::ostringstream stream; + const auto status = + FormatVerilog(test_case.input, "<filename>", style, stream); + EXPECT_OK(status) << status.message(); + EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; + } +} + +// Regression for https://github.com/chipsalliance/verible/issues/2544: +// Wrapping a $bits(...)'(...) cast may leave `MACRO at EOL, reclassifying +// MacroIdentifier as MacroIdItem. FormatEquivalent must accept that, and +// formatting must still pass verification. +TEST(FormatterEndToEndTest, MacroBeforeCloseParenFormatEquivalent) { + static constexpr std::string_view kInput = + "module m;\n" + " assign result_value = $bits(result_value)'( " + "compare_bytes(input_data[DATA_WIDTH_INT-1:0], " + "input_datak[STROBE_WIDTH_INT-1:0], `TOKEN_BYTE) );\n" + "endmodule\n"; + FormatStyle style; + std::ostringstream stream; + const auto status = FormatVerilog(kInput, "<filename>", style, stream); + EXPECT_OK(status) << status.message(); + EXPECT_THAT(stream.str(), testing::HasSubstr("`TOKEN_BYTE")); +} + +// Regression for https://github.com/chipsalliance/verible/issues/2542: +// Continuation EOL comments after a wrapped assign must keep a stable column +// across re-format (convergence). +TEST(FormatterEndToEndTest, ContinuationCommentAfterWrappedAssignConverges) { + static constexpr FormatterTestCase kTestCases[] = { + {// Comments originally column-aligned after a wrapped assign + "module m;\n" + " assign status_ur = !(status_sc || status_ca ||\n" + " status_crs); // Completions with a Reserved Completion\n" + " // Status value are treated as UR\n" + "endmodule\n", + "module m;\n" + " assign status_ur =\n" + " !(status_sc || status_ca || status_crs); // Completions with a " + "Reserved Completion\n" + " // Status value are " + "treated as UR\n" + "endmodule\n"}, + {// Previously mis-aligned continuation is not treated as a continuation + // (column delta > 1) and must still converge + "module m;\n" + " assign status_ur = !(status_sc || status_ca ||\n" + " status_crs); // Completions with a Reserved Completion\n" + " " + "// Status value are treated as UR\n" + "endmodule\n", + "module m;\n" + " assign status_ur =\n" + " !(status_sc || status_ca || status_crs); // Completions with a " + "Reserved Completion\n" + " // Status value are treated as UR\n" + "endmodule\n"}, + }; + FormatStyle style; // default column_limit (100) + for (const auto &test_case : kTestCases) { + VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; + std::ostringstream stream; + const auto status = + FormatVerilog(test_case.input, "<filename>", style, stream); + EXPECT_OK(status) << status.message(); + EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; + } +} + +// Regression for https://github.com/chipsalliance/verible/issues/2540: +// Trailing EOL comment after `end` before `else if` must not change whether +// the else-if assignment stays on one line across re-format (convergence). +TEST(FormatterEndToEndTest, EndElseIfWithEOLCommentConverges) { + static constexpr FormatterTestCase kTestCases[] = { + {// Comment on its own line between end and else if + "module m;\n" + " always_comb begin\n" + " case (state)\n" + " STATE_A: begin\n" + " if (cond_aaaa) next_state_value = STATE_B;\n" + " else if (cond_bbbb) begin\n" + " next_state_value = STATE_B;\n" + " end\n" + " // xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n" + " else if (cond_cccc) next_state_value = STATE_C;\n" + " end\n" + " endcase\n" + " end\n" + "endmodule\n", + "module m;\n" + " always_comb begin\n" + " case (state)\n" + " STATE_A: begin\n" + " if (cond_aaaa) next_state_value = STATE_B;\n" + " else if (cond_bbbb) begin\n" + " next_state_value = STATE_B;\n" + " end // xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n" + " else if (cond_cccc) next_state_value = STATE_C;\n" + " end\n" + " endcase\n" + " end\n" + "endmodule\n"}, + {// Same construct with comment already on the end line + "module m;\n" + " always_comb begin\n" + " case (state)\n" + " STATE_A: begin\n" + " if (cond_aaaa) next_state_value = STATE_B;\n" + " else if (cond_bbbb) begin\n" + " next_state_value = STATE_B;\n" + " end // xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n" + " else if (cond_cccc) next_state_value = STATE_C;\n" + " end\n" + " endcase\n" + " end\n" + "endmodule\n", + "module m;\n" + " always_comb begin\n" + " case (state)\n" + " STATE_A: begin\n" + " if (cond_aaaa) next_state_value = STATE_B;\n" + " else if (cond_bbbb) begin\n" + " next_state_value = STATE_B;\n" + " end // xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n" + " else if (cond_cccc) next_state_value = STATE_C;\n" + " end\n" + " endcase\n" + " end\n" + "endmodule\n"}, + }; + FormatStyle style; // default column_limit (100) + for (const auto &test_case : kTestCases) { + VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; + std::ostringstream stream; + const auto status = + FormatVerilog(test_case.input, "<filename>", style, stream); + EXPECT_OK(status) << status.message(); + EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; + } +} + +// Regression for https://github.com/chipsalliance/verible/issues/2008 +// (also https://github.com/chipsalliance/verible/issues/2474 and +// https://github.com/chipsalliance/verible/issues/2063): +// Non-ANSI "input wire signed" used to abort in the tree-unwrapper because +// the CST visited "signed" before "wire", which is the reverse of source +// order. +TEST(FormatterEndToEndTest, NonAnsiWireSignedModulePortDoesNotAbort) { + static constexpr FormatterTestCase kTestCases[] = { + {// Original issue #2008 sample + "module uut( sig1 );\n" + "\n" + "input wire signed [15:0] sig1;\n" + "\n" + "endmodule\n", + "module uut (\n" + " sig1\n" + ");\n" + "\n" + " input wire signed [15:0] sig1;\n" + "\n" + "endmodule\n"}, + {// Issue #2474 sample + "module myModule (\n" + " myinput\n" + ");\n" + "input wire signed [7:0] myInput;\n" + "endmodule\n", + "module myModule (\n" + " myinput\n" + ");\n" + " input wire signed [7:0] myInput;\n" + "endmodule\n"}, + {// Issue #2063 sample: signed wire with no packed dimensions + "module top(a);\n" + " input wire signed a;\n" + "endmodule\n", + "module top (\n" + " a\n" + ");\n" + " input wire signed a;\n" + "endmodule\n"}, + {// Same production with logic instead of wire + "module uut(sig1);\n" + "input logic signed [15:0] sig1;\n" + "endmodule\n", + "module uut (\n" + " sig1\n" + ");\n" + " input logic signed [15:0] sig1;\n" + "endmodule\n"}, + {// output / inout net types + "module uut(sig1, sig2);\n" + "output wire signed [15:0] sig1;\n" + "inout wire signed [7:0] sig2;\n" + "endmodule\n", + "module uut (\n" + " sig1,\n" + " sig2\n" + ");\n" + " output wire signed [15:0] sig1;\n" + " inout wire signed [7:0] sig2;\n" + "endmodule\n"}, + {// unsigned is the same production + "module uut(sig1);\n" + "input wire unsigned [15:0] sig1;\n" + "endmodule\n", + "module uut (\n" + " sig1\n" + ");\n" + " input wire unsigned [15:0] sig1;\n" + "endmodule\n"}, + {// ANSI form already worked; keep as a regression + "module uut(input wire signed [15:0] sig1);\n" + "endmodule\n", + "module uut (\n" + " input wire signed [15:0] sig1\n" + ");\n" + "endmodule\n"}, + {// Non-ANSI without signed still works + "module uut(sig1);\n" + "input wire [15:0] sig1;\n" + "endmodule\n", + "module uut (\n" + " sig1\n" + ");\n" + " input wire [15:0] sig1;\n" + "endmodule\n"}, + {// Non-ANSI signed without net type still works + "module uut(sig1);\n" + "input signed [15:0] sig1;\n" + "endmodule\n", + "module uut (\n" + " sig1\n" + ");\n" + " input signed [15:0] sig1;\n" + "endmodule\n"}, + }; + FormatStyle style; // default column_limit (100) + for (const auto &test_case : kTestCases) { + VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; + std::ostringstream stream; + const auto status = + FormatVerilog(test_case.input, "<filename>", style, stream); + EXPECT_OK(status) << status.message(); + EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; + } +} +} // namespace +} // namespace formatter +} // namespace verilog
diff --git a/verible/verilog/formatting/formatter_macro_test.cc b/verible/verilog/formatting/formatter_macro_test.cc new file mode 100644 index 0000000..25f4b90 --- /dev/null +++ b/verible/verilog/formatting/formatter_macro_test.cc
@@ -0,0 +1,555 @@ +// Copyright 2017-2026 The Verible Authors. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Test cases in this file should be *insensitive* to wrapping penalties. +// Penalty-sensitive tests belong in formatter-tuning_test.cc. + +#include "gtest/gtest.h" +#include "verible/verilog/formatting/formatter-test-utils.h" + +namespace verilog { +namespace formatter { +namespace { + +static constexpr FormatterTestCase kMacroFormatterTestCases[] = { + // preprocessor test cases + {"`include \"path/to/file.vh\"\n", "`include \"path/to/file.vh\"\n"}, + {"`include `\"path/to/file.vh`\"\n", "`include `\"path/to/file.vh`\"\n"}, + {"`define FOO\n", "`define FOO\n"}, + {"`define FOO BAR\n", "`define FOO BAR\n"}, + {"`define FOO\n" + "`define BAR\n", + "`define FOO\n" + "`define BAR\n"}, + {"`define FOO_``BAR 1\n", "`define FOO_``BAR 1\n"}, + {"`define FOO_```BAR 1\n", "`define FOO_```BAR 1\n"}, + {"`define FOO ``BAR\n", "`define FOO ``BAR\n"}, + {"`define A``B``C 2\n", "`define A``B``C 2\n"}, + {"`define A(x)``y\n", "`define A(x) ``y\n"}, + {"`define FOO_``BAR\n", "`define FOO_``BAR\n"}, + {"`ifndef FOO\n" + "`endif // FOO\n", + "`ifndef FOO\n" + "`endif // FOO\n"}, + {"`ifndef FOO\n" + "`define BAR\n" + "`endif\n", + "`ifndef FOO\n" + "`define BAR\n" + "`endif\n"}, + {"`ifndef FOO\n" + "`define BAR\n\n" // one more blank line + "`endif\n", + "`ifndef FOO\n" + "`define BAR\n\n" + "`endif\n"}, + {"`define FOO \\\n" + " BAR\n", + "`define FOO \\\n" // TODO(b/72527558): right align '\'s to column limit + " BAR\n"}, + {"`define FOOOOOOOOOOOOOOOO \\\n" + " BAAAAAAAAAAAAAAAAR BAAAAAAAAAAAAAZ;\n", + "`define FOOOOOOOOOOOOOOOO \\\n" // macro text starts at '\' + " BAAAAAAAAAAAAAAAAR BAAAAAAAAAAAAAZ;\n"}, + {"`ifdef FOO\n" + " `fine()\n" + "`else\n" + " `error()\n" + "`endif\n", + "`ifdef FOO\n" + "`fine()\n" + "`else\n" + "`error()\n" + "`endif\n"}, + {"`ifdef FOO\n" + " `fine()\n" + "`else // trouble\n" + " `error()\n" + "`endif\n", + "`ifdef FOO\n" + "`fine()\n" + "`else // trouble\n" + "`error()\n" + "`endif\n"}, + {"`ifdef FOO\n" + " `fine()\n" + "`else /* trouble */\n" + " `error()\n" + "`endif\n", + "`ifdef FOO\n" + "`fine()\n" + "`else /* trouble */\n" + "`error()\n" + "`endif\n"}, + {" // lonely comment\n", "// lonely comment\n"}, + {" // first comment\n" + " // last comment\n", + "// first comment\n" + "// last comment\n"}, + {" // starting comment\n" + " `define FOO\n", + "// starting comment\n" + "`define FOO\n"}, + {" `define FOO\n" + " // trailing comment\n", + "`define FOO\n" + "// trailing comment\n"}, + {" `define FOO\n" + " // trailing comment 1\n" + " // trailing comment 2\n", + "`define FOO\n" + "// trailing comment 1\n" + "// trailing comment 2\n"}, + { + " `define FOO \\\n" // multiline macro definition + " 1\n", + "`define FOO \\\n" + " 1\n" // TODO(b/141517267): Reflowing macro definitions + }, + {"`define FOO \\\n" // multiline macro definition + " b\n", + "`define FOO \\\n" // no need to align '\' + " b\n"}, + {"`define FOO \\\n" // multiline macro definition + " a + \\\n" + " b\n", + "`define FOO \\\n" // preserve spacing before '\' + " a + \\\n" // to stay aligned with this one + " b\n"}, + {" // comment with backslash\\\n", "// comment with backslash\\\n"}, + {// macro with MacroArg tokens as arguments + "`FOOOOOO(\nbar1...\n,\nbar2...\n,\nbar3...\n,\nbar4\n)\n", + "`FOOOOOO(bar1..., bar2..., bar3...,\n" + " bar4)\n"}, + {// macro declaration exceeds line length limit + "`F_MACRO(looooooong_type if_it_fits_I_sits)\n", + "`F_MACRO(\n" + " looooooong_type if_it_fits_I_sits)\n"}, + {// macro call with not fitting arguments + "`MACRO_FFFFFFFFFFF(" + "type_a_aaaa,type_b_bbbbb," + "type_c_cccccc,type_d_dddddddd," + "type_e_eeeeeeee,type_f_ffff)\n", + "`MACRO_FFFFFFFFFFF(\n" + " type_a_aaaa, type_b_bbbbb,\n" + " type_c_cccccc, type_d_dddddddd,\n" + " type_e_eeeeeeee, type_f_ffff)\n"}, + {// nested macro call + "`MACRO_FFFFFFFFFFF( " + "`A(type_a_aaaa), `B(type_b_bbbbb), " + "`C(type_c_cccccc), `D(type_d_dddddddd), " + "`E(type_e_eeeeeeee), `F(type_f_ffff))\n", + "`MACRO_FFFFFFFFFFF(`A(type_a_aaaa),\n" + " `B(type_b_bbbbb),\n" + " `C(type_c_cccccc),\n" + " `D(type_d_dddddddd),\n" + " `E(type_e_eeeeeeee),\n" + " `F(type_f_ffff))\n"}, + {// two-level nested macro call + "`MACRO_FFFFFFFFFFF( " + "`A(type_a_aaaa, `B(type_b_bbbbb)), " + "`C(type_c_cccccc, `D(type_d_dddddddd)), " + "`E(type_e_eeeeeeee, `F(type_f_ffff)))\n", + "`MACRO_FFFFFFFFFFF(\n" + " `A(type_a_aaaa, `B(type_b_bbbbb)),\n" + " `C(type_c_cccccc,\n" + " `D(type_d_dddddddd)),\n" + " `E(type_e_eeeeeeee,\n" + " `F(type_f_ffff)))\n"}, + {// three-level nested macro call + "`MACRO_FFFFFFFFFFF(`A(type_a_aaaa," + "`B(type_b_bbbbb,`C(type_c_cccccc)))," + "`D(type_d_dddddddd,`E(type_e_eeeeeeee," + "`F(type_f_ffff))))\n", + "`MACRO_FFFFFFFFFFF(\n" + " `A(type_a_aaaa,\n" + " `B(type_b_bbbbb,\n" + " `C(type_c_cccccc))),\n" + " `D(type_d_dddddddd,\n" + " `E(type_e_eeeeeeee,\n" + " `F(type_f_ffff))))\n"}, + {// macro call with MacroArg tokens as arugments and with semicolon + "`FOOOOOO(\nbar1...\n,\nbar2...\n,\nbar3...\n,\nbar4\n);\n", + "`FOOOOOO(bar1..., bar2..., bar3...,\n" + " bar4);\n"}, + {// macro declaration exceeds line length limit and contains semicolon + "`F_MACRO(looooooong_type if_it_fits_I_sits);\n", + "`F_MACRO(\n" + " looooooong_type if_it_fits_I_sits);\n"}, + {// macro call with not fitting arguments and semicolon + "`MACRO_FFFFFFFFFFF(" + "type_a_aaaa,type_b_bbbbb," + "type_c_cccccc,type_d_dddddddd," + "type_e_eeeeeeee,type_f_ffff);\n", + "`MACRO_FFFFFFFFFFF(\n" + " type_a_aaaa, type_b_bbbbb,\n" + " type_c_cccccc, type_d_dddddddd,\n" + " type_e_eeeeeeee, type_f_ffff);\n"}, + {// nested macro call with semicolon + "`MACRO_FFFFFFFFFFF( " + "`A(type_a_aaaa), `B(type_b_bbbbb), " + "`C(type_c_cccccc), `D(type_d_dddddddd), " + "`E(type_e_eeeeeeee), `F(type_f_ffff));\n", + "`MACRO_FFFFFFFFFFF(`A(type_a_aaaa),\n" + " `B(type_b_bbbbb),\n" + " `C(type_c_cccccc),\n" + " `D(type_d_dddddddd),\n" + " `E(type_e_eeeeeeee),\n" + " `F(type_f_ffff));\n"}, + {// two-level nested macro call with semicolon + "`MACRO_FFFFFFFFFFF( " + "`A(type_a_aaaa, `B(type_b_bbbbb)), " + "`C(type_c_cccccc, `D(type_d_dddddddd)), " + "`E(type_e_eeeeeeee, `F(type_f_ffff)));\n", + "`MACRO_FFFFFFFFFFF(\n" + " `A(type_a_aaaa, `B(type_b_bbbbb)),\n" + " `C(type_c_cccccc,\n" + " `D(type_d_dddddddd)),\n" + " `E(type_e_eeeeeeee,\n" + " `F(type_f_ffff)));\n"}, + {// three-level nested macro call with semicolon + "`MACRO_FFFFFFFFFFF(`A(type_a_aaaa," + "`B(type_b_bbbbb,`C(type_c_cccccc)))," + "`D(type_d_dddddddd,`E(type_e_eeeeeeee," + "`F(type_f_ffff))));\n", + "`MACRO_FFFFFFFFFFF(\n" + " `A(type_a_aaaa,\n" + " `B(type_b_bbbbb,\n" + " `C(type_c_cccccc))),\n" + " `D(type_d_dddddddd,\n" + " `E(type_e_eeeeeeee,\n" + " `F(type_f_ffff))));\n"}, + {// macro call with no args + "`FOOOOOO()\n", "`FOOOOOO()\n"}, + {// macro call with no args and semicolon + "`FOOOOOO();\n", "`FOOOOOO();\n"}, + {// macro call with no args and semicolon separated by space + "`FOOOOOO() ;\n", "`FOOOOOO();\n"}, + {// macro call with comments in argument list + "`FOO(aa, //aa\nbb , // bb\ncc)\n", + "`FOO(aa, //aa\n" + " bb, // bb\n" + " cc)\n"}, + {// macro call with comment before first argument + "`FOO(//aa\naa, //bb\nbb , // cc\ncc)\n", + "`FOO( //aa\n" + " aa, //bb\n" + " bb, // cc\n" + " cc)\n"}, + {// macro call with argument including trailing EOL comment + "`FOO(aa, bb,//cc\ndd)\n", + "`FOO(aa, bb, //cc\n" + " dd)\n"}, + {// macro call with argument including EOL comment on own line + "`FOOOO(aa, bb,\n//cc\ndd)\n", + "`FOOOO(aa, bb,\n" + " //cc\n" + " dd)\n"}, + {" // leading comment\n" + " `define FOO \\\n" // multiline macro definition + "1\n" + " // trailing comment\n", + "// leading comment\n" + "`define FOO \\\n" + "1\n" // TODO(b/141517267): Reflowing macro definitions + "// trailing comment\n"}, + {// macro call after define + "`define FOO BAR\n" + " `FOO( bar )\n", + "`define FOO BAR\n" + "`FOO(bar)\n"}, + {// multiple argument macro call + " `FOO( bar , baz )\n", "`FOO(bar, baz)\n"}, + {// long macro call breaking + " `ASSERT_INIT(S, (D == 4 && K inside {0, 1}) ||" + " (D == 3 && K== 4))\n", + "`ASSERT_INIT(\n" + " S, (D == 4 && K inside {0, 1}) ||\n" + " (D == 3 && K == 4))\n"}, + {// long macro call breaking + " `AINIT(S, (D == 4 && K inside {0, 1}) ||" + " (D == 3 && K== 4))\n", + "`AINIT(S, (D == 4 && K inside {0, 1}) ||\n" + " (D == 3 && K == 4))\n"}, + {// long macro call breaking + " `ASSERT_INIT(S, D == 4 && K inside {0, 1})\n", + "`ASSERT_INIT(S,\n" + " D == 4 && K inside {0, 1})\n"}, + {// macro call in function + "function void foo( ); foo=`FOO( bar , baz ) ; endfunction\n", + "function void foo();\n" + " foo = `FOO(bar, baz);\n" + "endfunction\n"}, + {// nested macro call in function + "function void foo( ); foo=`FOO( `BAR ( baz ) ) ; endfunction\n", + "function void foo();\n" + " foo = `FOO(`BAR(baz));\n" + "endfunction\n"}, + {// macro call in class + "class foo; `FOO ( bar , baz ) ; endclass\n", + "class foo;\n" + " `FOO(bar, baz);\n" + "endclass\n"}, + {// nested macro call in class + "class foo; `FOO ( `BAR ( baz1 , baz2 ) ) ; endclass\n", + "class foo;\n" + " `FOO(`BAR(baz1, baz2));\n" + "endclass\n"}, + {// multi-line macro arg "aaaa..." should start on its own line, + // even if its first line would fit under the column limit + "`CHECK_FATAL(rd_tr,\n" + " aaaa == zzz;\n" + " ggg == vv::w;,\n" + " \"Failed to ..........\")\n", + "`CHECK_FATAL(rd_tr,\n" + " aaaa == zzz;\n" + " ggg == vv::w;,\n" + " \"Failed to ..........\")\n"}, + {// macro call nested with function call containing an ifdef + "`J(D(`ifdef e))\n", + "`J(D(\n" + " `ifdef e))\n"}, + + // `uvm macros indenting + { + // simple test case + "`uvm_object_utils_begin(aa)\n" + "`uvm_field_int(bb, UVM_DEFAULT)\n" + "`uvm_field_int(cc, UVM_DEFAULT)\n" + "`uvm_object_utils_end\n", + "`uvm_object_utils_begin(aa)\n" + " `uvm_field_int(bb, UVM_DEFAULT)\n" + " `uvm_field_int(cc, UVM_DEFAULT)\n" + "`uvm_object_utils_end\n", + }, + {// multiple uvm.*begin - uvm.*end ranges + "`uvm_object_utils_begin(aa)\n" + "`uvm_field_int(bb, UVM_DEFAULT)\n" + "`uvm_field_int(cc, UVM_DEFAULT)\n" + "`uvm_object_utils_end\n" + "`uvm_field_int(bb, UVM_DEFAULT)\n" + "`uvm_field_int(cc, UVM_DEFAULT)\n" + "`uvm_object_utils_begin(bb)\n" + "`uvm_field_int(bb, UVM_DEFAULT)\n" + "`uvm_field_int(cc, UVM_DEFAULT)\n" + "`uvm_object_utils_end\n" + "`uvm_field_int(bb, UVM_DEFAULT)\n" + "`uvm_field_int(cc, UVM_DEFAULT)\n", + "`uvm_object_utils_begin(aa)\n" + " `uvm_field_int(bb, UVM_DEFAULT)\n" + " `uvm_field_int(cc, UVM_DEFAULT)\n" + "`uvm_object_utils_end\n" + "`uvm_field_int(bb, UVM_DEFAULT)\n" + "`uvm_field_int(cc, UVM_DEFAULT)\n" + "`uvm_object_utils_begin(bb)\n" + " `uvm_field_int(bb, UVM_DEFAULT)\n" + " `uvm_field_int(cc, UVM_DEFAULT)\n" + "`uvm_object_utils_end\n" + "`uvm_field_int(bb, UVM_DEFAULT)\n" + "`uvm_field_int(cc, UVM_DEFAULT)\n"}, + { + // empty uvm.*begin - uvm.*end range + "`uvm_component_utils_begin(aa)\n" + "`uvm_component_utils_end\n", + "`uvm_component_utils_begin(aa)\n" + "`uvm_component_utils_end\n", + }, + { + // uvm_field_utils + "`uvm_field_utils_begin(aa)\n" + "`uvm_field_int(bb, UVM_DEFAULT)\n" + "`uvm_field_int(cc, UVM_DEFAULT)\n" + "`uvm_field_utils_end\n", + "`uvm_field_utils_begin(aa)\n" + " `uvm_field_int(bb, UVM_DEFAULT)\n" + " `uvm_field_int(cc, UVM_DEFAULT)\n" + "`uvm_field_utils_end\n", + }, + { + // uvm_component + "`uvm_component_utils_begin(aa)\n" + "`uvm_field_int(bb, UVM_DEFAULT)\n" + "`uvm_field_int(cc, UVM_DEFAULT)\n" + "`uvm_component_utils_end\n", + "`uvm_component_utils_begin(aa)\n" + " `uvm_field_int(bb, UVM_DEFAULT)\n" + " `uvm_field_int(cc, UVM_DEFAULT)\n" + "`uvm_component_utils_end\n", + }, + { + // nested uvm macros + "`uvm_field_int(l0, UVM_DEFAULT)\n" + "`uvm_component_utils_begin(l0)\n" + "`uvm_field_int(l1, UVM_DEFAULT)\n" + "`uvm_component_utils_begin(l1)\n" + "`uvm_field_int(l2, UVM_DEFAULT)\n" + "`uvm_component_utils_begin(l2)\n" + "`uvm_field_int(l3, UVM_DEFAULT)\n" + "`uvm_component_utils_end\n" + "`uvm_field_int(l2, UVM_DEFAULT)\n" + "`uvm_component_utils_end\n" + "`uvm_field_int(l1, UVM_DEFAULT)\n" + "`uvm_component_utils_end\n" + "`uvm_field_int(l0, UVM_DEFAULT)\n", + "`uvm_field_int(l0, UVM_DEFAULT)\n" + "`uvm_component_utils_begin(l0)\n" + " `uvm_field_int(l1, UVM_DEFAULT)\n" + " `uvm_component_utils_begin(l1)\n" + " `uvm_field_int(l2, UVM_DEFAULT)\n" + " `uvm_component_utils_begin(l2)\n" + " `uvm_field_int(l3, UVM_DEFAULT)\n" + " `uvm_component_utils_end\n" + " `uvm_field_int(l2, UVM_DEFAULT)\n" + " `uvm_component_utils_end\n" + " `uvm_field_int(l1, UVM_DEFAULT)\n" + "`uvm_component_utils_end\n" + "`uvm_field_int(l0, UVM_DEFAULT)\n", + }, + { + // non-uvm macro + "`my_macro_begin(aa)\n" + "`my_field(b)\n" + "`my_field(c)\n" + "`my_macro_end\n", + "`my_macro_begin(aa)\n" + "`my_field(b)\n" + "`my_field(c)\n" + "`my_macro_end\n", + }, + { + // unbalanced uvm macros: missing uvm.*end macro + "`uvm_component_utils_begin(aa)\n" + "`uvm_field_int(bb, UVM_DEFAULT)\n" + "`uvm_field_int(cc, UVM_DEFAULT)\n", + "`uvm_component_utils_begin(aa)\n" + "`uvm_field_int(bb, UVM_DEFAULT)\n" + "`uvm_field_int(cc, UVM_DEFAULT)\n", + }, + { + // unbalanced uvm macros: missing uvm.*begin macro + "`uvm_field_int(bb, UVM_DEFAULT)\n" + "`uvm_field_int(cc, UVM_DEFAULT)\n" + "`uvm_component_utils_end\n", + "`uvm_field_int(bb, UVM_DEFAULT)\n" + "`uvm_field_int(cc, UVM_DEFAULT)\n" + "`uvm_component_utils_end\n", + }, + {// unbalanced uvm macros: missing _begin macro between + // matching uvm.*begin-uvm.*end macros + "`uvm_component_utils_begin(aa)\n" + "`uvm_field_int(bb, UVM_DEFAULT)\n" + "`uvm_field_int(cc, UVM_DEFAULT)\n" + "`uvm_component_utils_end\n" + "`uvm_field_int(bb, UVM_DEFAULT)\n" + "`uvm_field_int(bb, UVM_DEFAULT)\n" + "`uvm_field_int(cc, UVM_DEFAULT)\n" + "`uvm_component_utils_end\n" + "`uvm_field_int(bb, UVM_DEFAULT)\n" + "`uvm_component_utils_begin(aa)\n" + "`uvm_field_int(bb, UVM_DEFAULT)\n" + "`uvm_field_int(cc, UVM_DEFAULT)\n" + "`uvm_component_utils_end\n", + "`uvm_component_utils_begin(aa)\n" + " `uvm_field_int(bb, UVM_DEFAULT)\n" + " `uvm_field_int(cc, UVM_DEFAULT)\n" + "`uvm_component_utils_end\n" + "`uvm_field_int(bb, UVM_DEFAULT)\n" + "`uvm_field_int(bb, UVM_DEFAULT)\n" + "`uvm_field_int(cc, UVM_DEFAULT)\n" + "`uvm_component_utils_end\n" + "`uvm_field_int(bb, UVM_DEFAULT)\n" + "`uvm_component_utils_begin(aa)\n" + " `uvm_field_int(bb, UVM_DEFAULT)\n" + " `uvm_field_int(cc, UVM_DEFAULT)\n" + "`uvm_component_utils_end\n"}, + + // top-level directive test cases + {"`timescale 1ns/1ps\n", // + "`timescale 1ns / 1ps\n"}, + + // Multiple compiler directives should remain on separate lines + // (regression test for bug where they were merged onto one line) + {"`timescale 1 ps / 1 ps\n" + "`default_nettype none\n", + "`timescale 1 ps / 1 ps\n" + "`default_nettype none\n"}, + {"`resetall\n" + "`timescale 1ns/1ps\n" + "`default_nettype wire\n", + "`resetall\n" + "`timescale 1ns / 1ps\n" + "`default_nettype wire\n"}, + // Test with multiple different compiler directives + {"`resetall\n" + "`celldefine\n" + "`timescale 1ns/1ps\n" + "`default_nettype none\n", + "`resetall\n" + "`celldefine\n" + "`timescale 1ns / 1ps\n" + "`default_nettype none\n"}, + // Test with compiler directives before module + {"`timescale 1ps/1ps\n" + "`default_nettype none\n" + "module foo;endmodule\n", + "`timescale 1ps / 1ps\n" + "`default_nettype none\n" + "module foo;\nendmodule\n"}, + // Test with various compiler directives + {"`suppress_faults\n" + "`enable_portfaults\n" + "`delay_mode_distributed\n", + "`suppress_faults\n" + "`enable_portfaults\n" + "`delay_mode_distributed\n"}, + {"`default_decay_time 10\n" + "`default_trireg_strength 50\n", + "`default_decay_time 10\n" + "`default_trireg_strength 50\n"}, + // Alignment should ignore compiler directives; declarations align normally. + // Place directives at top-level between modules (valid SystemVerilog). + {"`timescale 1ns/1ps\n" + "module m;\n" + " logic a;\n" + " logic very_long_name;\n" + "endmodule\n" + "`default_nettype none\n" + "module n;\n" + " logic b;\n" + "endmodule\n", + "`timescale 1ns / 1ps\n" + "module m;\n" + " logic a;\n" + " logic very_long_name;\n" + "endmodule\n" + "`default_nettype none\n" + "module n;\n" + " logic b;\n" + "endmodule\n"}, + {"`begin_keywords \"1800-2017\"\n" + "module test;endmodule\n" + "`end_keywords\n", + "`begin_keywords \"1800-2017\"\n" + "module test;\nendmodule\n" + "`end_keywords\n"}, + +}; + +TEST(FormatterEndToEndTest, MacroFormatterTestCases) { + RunFormatterTestCases40(kMacroFormatterTestCases); +} + +} // namespace +} // namespace formatter +} // namespace verilog
diff --git a/verible/verilog/formatting/formatter_module_test.cc b/verible/verilog/formatting/formatter_module_test.cc new file mode 100644 index 0000000..4290e5e --- /dev/null +++ b/verible/verilog/formatting/formatter_module_test.cc
@@ -0,0 +1,3025 @@ +// Copyright 2017-2026 The Verible Authors. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Test cases in this file should be *insensitive* to wrapping penalties. +// Penalty-sensitive tests belong in formatter-tuning_test.cc. + +#include "gtest/gtest.h" +#include "verible/verilog/formatting/formatter-test-utils.h" + +namespace verilog { +namespace formatter { +namespace { + +static constexpr FormatterTestCase kModuleFormatterTestCases[] = { + // parameter test cases + { + " parameter int foo=0 ;", + "parameter int foo = 0;\n", + }, + { + " parameter int foo=bar [ 0 ] ;", // index expression + "parameter int foo = bar[0];\n", + }, + { + " parameter int foo=bar [ a+b ] ;", // binary inside index expr + "parameter int foo = bar[a+b];\n", // allowed to be 0 spaces + // (preserved) + }, + { + " parameter int foo=bar [ a+ b ] ;", // binary inside index expr + "parameter int foo = bar[a+b];\n", // allowed to be 0 spaces + // (symmetrized) + }, + { + " parameter int foo=bar [ a +b ] ;", // compact binary inside + "parameter int foo = bar[a+b];\n", // index expression + }, + { + " parameter int foo=bar [ a +b ] ;", // compact binary inside + "parameter int foo = bar[a+b];\n", // index expression + }, + { + // with line continuations + " parameter \\\nint \\\nfoo=a+ \\\nb ;", + "parameter\\\n int\\\n foo = a +\\\n b;\n", + // TODO(fangism): should text following a line continuation hang-indent? + }, + // unary prefix expressions + { + " parameter int foo=- 1 ;", + "parameter int foo = -1;\n", + }, + { + " parameter int foo=+ 7 ;", + "parameter int foo = +7;\n", + }, + { + " parameter int foo=- J ;", + "parameter int foo = -J;\n", + }, + { + " parameter int foo=- ( y ) ;", + "parameter int foo = -(y);\n", + }, + { + " parameter int foo=- ( z*y ) ;", + "parameter int foo = -(z * y);\n", + }, + { + " parameter int foo=- z*- y ;", + "parameter int foo = -z * -y;\n", + }, + { + " parameter int foo=( - 2 ) ;", // + "parameter int foo = (-2);\n", + }, + { + " parameter int foo=$bar(- z,- y ) ;", + "parameter int foo = $bar(-z, -y);\n", + }, + {" parameter int a=b&~(c<<d);", "parameter int a = b & ~(c << d);\n"}, + {" parameter int a=~~~~b;", "parameter int a = ~~~~b;\n"}, + {" parameter int a = ~ ~ ~ ~ b;", "parameter int a = ~~~~b;\n"}, + {" parameter int a = ~--b;", "parameter int a = ~--b;\n"}, + {" parameter int a = ~ --b;", "parameter int a = ~--b;\n"}, + {" parameter int a = ~ ++ b;", "parameter int a = ~++b;\n"}, + {" parameter int a=--b- --c;", "parameter int a = --b - --c;\n"}, + // ^~ and ~^ are bitwise nor, but ^ ~ isn't + {" parameter int a=b^~(c<<d);", "parameter int a = b ^~ (c << d);\n"}, + {" parameter int a=b~^(c<<d);", "parameter int a = b ~^ (c << d);\n"}, + {" parameter int a=b^ ~ (c<<d);", "parameter int a = b ^ ~(c << d);\n"}, + {" parameter int a=b ^ ~(c<<d);", "parameter int a = b ^ ~(c << d);\n"}, + + {" parameter int a=b^~{c};", "parameter int a = b ^~ {c};\n"}, + {" parameter int a=b~^{c};", "parameter int a = b ~^ {c};\n"}, + {" parameter int a=b^ ~ {c};", "parameter int a = b ^ ~{c};\n"}, + {" parameter int a=b ^ ~{c};", "parameter int a = b ^ ~{c};\n"}, + + {" parameter int a={a}^{b};", "parameter int a = {a} ^ {b};\n"}, + {" parameter int a={b}^(c);", "parameter int a = {b} ^ (c);\n"}, + {" parameter int a=b[0]^ {c};", "parameter int a = b[0] ^ {c};\n"}, + {" parameter int a={c}^a[b];", "parameter int a = {c} ^ a[b];\n"}, + {" parameter int a=(c)^{a[b]};", "parameter int a = (c) ^ {a[b]};\n"}, + + {" parameter int a={^{a,^b},c};", "parameter int a = {^{a, ^b}, c};\n"}, + {" parameter int a=(a)^(^d[e]^{c});", + "parameter int a = (a) ^ (^d[e] ^ {c});\n"}, + {" parameter int a=(a)^(^d[e]^f[g]);", + "parameter int a = (a) ^ (^d[e] ^ f[g]);\n"}, + {" parameter int a=(b^(c^(d^e)));", + "parameter int a = (b ^ (c ^ (d ^ e)));\n"}, + {" parameter int a={b^{c^{d^e}}};", + "parameter int a = {b ^ {c ^ {d ^ e}}};\n"}, + {" parameter int a={b^{c[d^e]}};", + "parameter int a = {b ^ {c[d^e]}};\n"}, // allow 0 spaces inside "[d^e]" + {" parameter int a={(b^c),(d^^e)};", + "parameter int a = {(b ^ c), (d ^ ^e)};\n"}, + + {" parameter int a={(b[x]^{c[y]})};", + "parameter int a = {(b[x] ^ {c[y]})};\n"}, + {" parameter int a={d^^e[f] ^ (g)};", + "parameter int a = {d ^ ^e[f] ^ (g)};\n"}, + + // ~| is unary reduction NOR, |~ and | ~ aren't + {" parameter int a=b| ~(c<<d);", "parameter int a = b | ~(c << d);\n"}, + {" parameter int a=b|~(c<<d);", "parameter int a = b | ~(c << d);\n"}, + {" parameter int a=b| ~| ( c<<d);", "parameter int a = b | ~|(c << d);\n"}, + {" parameter int a=b| ~| ~| ( c<<d);", + "parameter int a = b | ~|~|(c << d);\n"}, + {" parameter int a=b| ~~~( c<<d);", + "parameter int a = b | ~~~(c << d);\n"}, + { + " parameter int foo=- - 1 ;", // double negative + "parameter int foo = - -1;\n", + }, + { + " parameter int ternary=1?2:3;", + "parameter int ternary = 1 ? 2 : 3;\n", + }, + { + " parameter int ternary=a?b:c;", + "parameter int ternary = a ? b : c;\n", + }, + { + " parameter int ternary=\"a\"?\"b\":\"c\";", + "parameter int ternary = \"a\" ? \"b\" : \"c\";\n", + }, + { + " parameter int t=`\"a`\"?`\"b`\":`\"c`\";", + "parameter int t = `\"a`\" ? `\"b`\" : `\"c`\";\n", + }, + { + " parameter int ternary=(a)?(b):(c);", + "parameter int ternary = (a) ? (b) : (c);\n", + }, + { + " parameter int ternary={a}?{b}:{c};", + "parameter int ternary = {a} ? {b} : {c};\n", + }, + { + " parameter int long_ternary=cond?long_option_t:long_option_f;", + "parameter int long_ternary = cond ?\n" + " long_option_t : long_option_f;\n", + }, + { + " parameter int break_two=cond\n" + "? a_really_long_option_number_one:a_really_long_option_number_two;", + "parameter int break_two = cond ?\n" + " a_really_long_option_number_one :\n" + " a_really_long_option_number_two;\n", + }, + { + " assign ternary=1?2:3;", + "assign ternary = 1 ? 2 : 3;\n", + }, + { + " assign ternary=a?b:c;", + "assign ternary = a ? b : c;\n", + }, + { + " assign ternary={a}?{b}:{c};", + "assign ternary = {a} ? {b} : {c};\n", + }, + { + " assign break_two=cond\n" + "? a_really_long_option_number_one:a_really_long_option_number_two;", + "assign break_two = cond ?\n" + " a_really_long_option_number_one :\n" + " a_really_long_option_number_two;\n", + }, + { + "assign prefetch_d =\n" + "lookup_grant_ic0 ? (lookup_addr_aligned + ADDR) :\n" + " addr_i;", + "assign prefetch_d = lookup_grant_ic0 ?\n" + " (lookup_addr_aligned + ADDR) :\n" + " addr_i;\n", + }, + { + "assign prefetch_d =\n" + "lookup_grant_ic0 ? (lookup_addr + 1) :\n" + " addr_i;", + "assign prefetch_d = lookup_grant_ic0 ?\n" + " (lookup_addr + 1) : addr_i;\n", + }, + { + "module test;\n" + " assign next = // EOL\n" + " foo ? '0 :\n" + " cnt;\n" + "endmodule\n", + "module test;\n" + " assign next = // EOL\n" + " foo ? '0 : cnt;\n" + "endmodule\n", + }, + { + "module test;\n" + " assign next = foo // EOL\n" + " ? '0 :\n" + " cnt;\n" + "endmodule\n", + "module test;\n" + " assign next = foo // EOL\n" + " ? '0 : cnt;\n" + "endmodule\n", + }, + { + "module test;\n" + " assign next = foo ? // EOL\n" + " '0 :\n" + " cnt;\n" + "endmodule\n", + "module test;\n" + " assign next = foo ? // EOL\n" + " '0 : cnt;\n" + "endmodule\n", + }, + { + "module test;\n" + " assign next = foo ? '0 // EOL\n" + " :\n" + " cnt;\n" + "endmodule\n", + "module test;\n" + " assign next = foo ? '0 // EOL\n" + " : cnt;\n" + "endmodule\n", + }, + { + "module test;\n" + " assign next = foo ? '0 : // EOL\n" + " cnt;\n" + "endmodule\n", + "module test;\n" + " assign next = foo ? '0 : // EOL\n" + " cnt;\n" + "endmodule\n", + }, + { + "module test;\n" + " assign next = foo ? '0 : // EOL\n" + " bar ? '1 : '0;\n" + "endmodule\n", + "module test;\n" + " assign next = foo ? '0 : // EOL\n" + " bar ? '1 : '0;\n" + "endmodule\n", + }, + { + "module test;\n" + " assign next = foo ? '0 : // EOL\n" + " bar // EOL2\n" + " ? '1 : '0;\n" + "endmodule\n", + "module test;\n" + " assign next = foo ? '0 : // EOL\n" + " bar // EOL2\n" + " ? '1 : '0;\n" + "endmodule\n", + }, + { + "module test;\n" + " assign next = foo ? '0 : // EOL\n" + " bar ? // EOL2\n" + " '1 : '0;\n" + "endmodule\n", + "module test;\n" + " assign next = foo ? '0 : // EOL\n" + " bar ? // EOL2\n" + " '1 : '0;\n" + "endmodule\n", + }, + { + "module test;\n" + " assign next = foo ? '0 : // EOL\n" + " bar ? '1 // EOL2\n" + " : '0;\n" + "endmodule\n", + "module test;\n" + " assign next = foo ? '0 : // EOL\n" + " bar ? '1 // EOL2\n" + " : '0;\n" + "endmodule\n", + }, + { + "module test;\n" + " assign next = foo ? '0 : // EOL\n" + " bar ? '1 : // EOL2\n" + " '0;\n" + "endmodule\n", + "module test;\n" + " assign next = foo ? '0 : // EOL\n" + " bar ? '1 : // EOL2\n" + " '0;\n" + "endmodule\n", + }, + { + "assign prefetch_d =\n" + "lookup_ic0 ? // EOL\n" + " (lookup_addr + 1) :// BOO\n" + " addr_i;", + "assign prefetch_d = lookup_ic0 ? // EOL\n" + " (lookup_addr + 1) : // BOO\n" + " addr_i;\n", + }, + { + "module test;\n" + " assign next = (foo) ? '0 : // clear \n" + " (bar) ? cnt + 1'b1 : // count \n" + " cnt;\n" + "endmodule\n", + "module test;\n" + " assign next = (foo) ? '0 : // clear \n" + " (bar) ? cnt + 1'b1 : // count \n" + " cnt;\n" + "endmodule\n", + }, + { + "module test;\n" + " assign next = // FOO\n" + " (foo) ? '0 : // clear \n" + " (bar) ? cnt + 1'b1 : // count \n" + " cnt;\n" + "endmodule\n", + "module test;\n" + " assign next = // FOO\n" + " (foo) ? '0 : // clear \n" + " (bar) ? cnt + 1'b1 : // count \n" + " cnt;\n" + "endmodule\n", + }, + { + "module test;\n" + " assign next = foo ? a_really_long_identifier : // EOL\n" + " cnt;\n" + "endmodule\n", + "module test;\n" + " assign next = foo ?\n" + " a_really_long_identifier : // EOL\n" + " cnt;\n" + "endmodule\n", + }, + { + "module test;\n" + " assign next = foo ? a_really_long_identifier : // EOL\n" + " another_really_long_identifier;\n" + "endmodule\n", + "module test;\n" + " assign next = foo ?\n" + " a_really_long_identifier : // EOL\n" + " another_really_long_identifier;\n" + "endmodule\n", + }, + { + "module test;\n" + " assign next = foo ? a_really_long_identifier : " + "another_really_long_identifier;\n" + "endmodule\n", + "module test;\n" + " assign next = foo ?\n" + " a_really_long_identifier :\n" + " another_really_long_identifier;\n" + "endmodule\n", + }, + { + "assign m = check ? {10'b0, foo} :\n" + " (bar && (baz == '0)) ? hello :\n" + " world ? temp1 : temp2;\n", + "assign m = check ? {10'b0, foo} :\n" + " (bar && (baz == '0)) ? hello :\n" + " world ? temp1 : temp2;\n", + }, + { + "assign {a, b} = !(c == d) ? {1'b0, e} :\n" + " ((e == f) && g) ?\n" + " {1'b0, f} : (h) ?\n" + " {1'b0, e} - 1'b1 :\n" + " {1'b0, e} + 1'b1;\n", + "assign {a, b} = !(c == d) ? {1'b0, e} :\n" + " ((e == f) && g) ? {1'b0, f} : (h) ?\n" + " {1'b0, e} - 1'b1 : {1'b0, e} + 1'b1;\n", + }, + { + "assign {aaaaaaaaaa, bbbbbbbbb} = {1'b0, cccccccccccccccccc[15:0]} +\n" + " {1'b0, ddddddddddddddddd[15:0]};\n", + "assign {aaaaaaaaaa, bbbbbbbbb} =\n" + " {1'b0, cccccccccccccccccc[15:0]} +\n" + " {1'b0, ddddddddddddddddd[15:0]};\n", + }, + { + "covergroup a(string b);\n" + "foobar: cross foo, bar {" + "ignore_bins baz = binsof(qux) intersect {1, 2, 3, 4, 5, 6, 7};" + "}\n" + "endgroup : a\n", + "covergroup a(string b);\n" + " foobar: cross foo, bar{\n" + " ignore_bins baz =\n" + " binsof (qux) intersect {\n" + " 1, 2, 3, 4, 5, 6, 7\n" + " };\n" + " }\n" + "endgroup : a\n", + }, + { + "assign {aa, bb} = {1'b0, cc} + {1'b0, dd};\n", + "assign {aa, bb} = {1'b0, cc} +\n" + " {1'b0, dd};\n", + }, + + // streaming operators + { + " parameter int b={ >> { a } } ;", + "parameter int b = {>>{a}};\n", + }, + { + " parameter int b={ >> { a , b, c } } ;", + "parameter int b = {>>{a, b, c}};\n", + }, + { + " parameter int b={ >> 4 { a } } ;", + "parameter int b = {>>4{a}};\n", + }, + { + " parameter int b={ >> byte { a } } ;", + "parameter int b = {>>byte{a}};\n", + }, + { + " parameter int b={ >> my_type_t { a } } ;", + "parameter int b = {>>my_type_t{a}};\n", + }, + { + " parameter int b={ >> `GET_TYPE { a } } ;", + "parameter int b = {>>`GET_TYPE{a}};\n", + }, + { + " parameter int b={ >> 4 {{ >> 2 { a } }} } ;", + "parameter int b = {>>4{{>>2{a}}}};\n", + }, + { + " parameter int b={ << { a } } ;", + "parameter int b = {<<{a}};\n", + }, + { + " parameter int b={ << { a , b, c } } ;", + "parameter int b = {<<{a, b, c}};\n", + }, + { + " parameter int b={ << 4 { a } } ;", + "parameter int b = {<<4{a}};\n", + }, + { + " parameter int b={ << byte { a } } ;", + "parameter int b = {<<byte{a}};\n", + }, + { + " parameter int b={ << my_type_t { a } } ;", + "parameter int b = {<<my_type_t{a}};\n", + }, + { + " parameter int b={ << `GET_TYPE { a } } ;", + "parameter int b = {<<`GET_TYPE{a}};\n", + }, + { + " parameter int b={ << 4 {{ << 2 { a } }} } ;", + "parameter int b = {<<4{{<<2{a}}}};\n", + }, + + // basic module test cases + {"module foo;endmodule:foo\n", + "module foo;\n" + "endmodule : foo\n"}, + {"module\nfoo\n;\nendmodule\n:\nfoo\n", + "module foo;\n" + "endmodule : foo\n"}, + {"module\tfoo\t;\tendmodule\t:\tfoo", + "module foo;\n" + "endmodule : foo\n"}, + {"module foo; // foo\n" + "endmodule:foo\n", + "module foo; // foo\n" + "endmodule : foo\n"}, + {"module foo;/* foo */endmodule:foo\n", + "module foo; /* foo */\n" + "endmodule : foo\n"}, + {"module pm #(\n" + "//comment\n" + ") (wire ww);\n" + "endmodule\n", + "module pm #(\n" + " //comment\n" // comment indented + ") (\n" + " wire ww\n" + ");\n" + "endmodule\n"}, + {"module pm ( ) ;\n" // empty ports list + "endmodule\n", + "module pm ();\n" + "endmodule\n"}, + {"module pm #(\n" + "//comment\n" + ") ( );\n" + "endmodule\n", + "module pm #(\n" + " //comment\n" // comment indented + ") ();\n" // (); grouped together + "endmodule\n"}, + {"`ifdef FOO\n" + " `ifndef BAR\n" + " `endif\n" + "`endif\n", + "`ifdef FOO\n" + "`ifndef BAR\n" + "`endif\n" + "`endif\n"}, + {"module foo(\n" + " `include \"ports.svh\"\n" + " ) ; endmodule\n", + "module foo (\n" + " `include \"ports.svh\"\n" + ");\n" + "endmodule\n"}, + {"module foo(\n" + " `define FOO\n" + "`undef\tFOO\n" + " ) ; endmodule\n", + "module foo (\n" + " `define FOO\n" + " `undef FOO\n" + ");\n" + "endmodule\n"}, + {"module foo( input x , output y ) ;endmodule:foo\n", + "module foo (\n" + " input x,\n" // aligned + " output y\n" + ");\n" + "endmodule : foo\n"}, + {"module foo(\n" + "// comment\n" + " input x , output y ) ;endmodule:foo\n", + "module foo (\n" + " // comment\n" + " input x,\n" // aligned + " output y\n" + ");\n" + "endmodule : foo\n"}, + {"module foo( input[2:0]x , output y [3:0] ) ;endmodule:foo\n", + // each port item should be on its own line + "module foo (\n" + " input [2:0] x,\n" // aligned + " output y[3:0]\n" + ");\n" + "endmodule : foo\n"}, + {"module foo( input wire x , output reg yy ) ;endmodule:foo\n", + "module foo (\n" + " input wire x,\n" // aligned + " output reg yy\n" + ");\n" + "endmodule : foo\n"}, + {"module foo( input wire x ,//c1\n" + "output reg yyy //c2\n" + " ) ;endmodule:foo\n", + "module foo (\n" + " input wire x, //c1\n" // aligned + " output reg yyy //c2\n" // aligned + ");\n" + "endmodule : foo\n"}, + {"module foo( input wire x ,/* c1 */\n" + "output reg yyy /* c2 */\n" + " ) ;endmodule:foo\n", + "module foo (\n" + " input wire x, /* c1 */\n" // aligned + " output reg yyy /* c2 */\n" // aligned + ");\n" + "endmodule : foo\n"}, + {"module foo(\n" + "// comment\n" + "input wire x ,//c1\n" + "output reg yyy //c2\n" + " ) ;endmodule:foo\n", + "module foo (\n" + " // comment\n" + " input wire x, //c1\n" // aligned + " output reg yyy //c2\n" // aligned + ");\n" + "endmodule : foo\n"}, + {"module foo(\n" + "/* comment */\n" + "input wire x ,/* c1 */\n" + "output reg yyy /* c2 */\n" + " ) ;endmodule:foo\n", + "module foo (\n" + " /* comment */\n" + " input wire x, /* c1 */\n" // aligned + " output reg yyy /* c2 */\n" // aligned + ");\n" + "endmodule : foo\n"}, + {"module foo( input wire x ,/* c1\n" + "c2\n" + "c3 */\n" + "output reg yyy /* c4 */\n" + " ) ;endmodule:foo\n", + "module foo (\n" + " input wire x, /* c1\n" + "c2\n" + "c3 */\n" // TODO: align multiline comments + " output reg yyy /* c4 */\n" + ");\n" + "endmodule : foo\n"}, + {"module foo( input wire x ,/* c1 */\n" + "output reg yyy,\n" + "output z // c2\n" + " ) ;endmodule:foo\n", + "module foo (\n" + " input wire x, /* c1 */\n" // aligned + " output reg yyy,\n" + " output z // c2\n" // aligned + ");\n" + "endmodule : foo\n"}, + {"module m(input logic [4:0] foo, // comment\n" + "input logic bar // comment\n" + " ) ;endmodule:m\n", + "module m (\n" + " input logic [4:0] foo, // comment\n" // aligned + " input logic bar // comment\n" // aligned + ");\n" + "endmodule : m\n"}, + {"module foo( input wire x , output yy ) ;endmodule:foo\n", + "module foo (\n" + " input wire x,\n" // aligned + " output yy\n" + ");\n" + "endmodule : foo\n"}, + {"module foo( input x , output reg yy ) ;endmodule:foo\n", + "module foo (\n" + " input x,\n" // aligned + " output reg yy\n" + ");\n" + "endmodule : foo\n"}, + {"module foo( input x , output reg[a:b]yy ) ;endmodule:foo\n", + "module foo (\n" + " input x,\n" // aligned + " output reg [a:b] yy\n" + ");\n" + "endmodule : foo\n"}, + {"module foo( input [a:b]x , output reg yy ) ;endmodule:foo\n", + "module foo (\n" + " input [a:b] x,\n" // aligned + " output reg yy\n" + ");\n" + "endmodule : foo\n"}, + {"module foo( input x , " + " output logic yy ) ;endmodule:foo\n", + "module foo (\n" + " input x,\n" // aligned + " output logic yy\n" + ");\n" + "endmodule : foo\n"}, + {"module foo( input [a:c]x , " + " output logic[a-b: c] yy ) ;endmodule:foo\n", + "module foo (\n" + " input [ a:c] x,\n" // aligned + " output logic [a-b:c] yy\n" + ");\n" + "endmodule : foo\n"}, + {"module foo( input [a:c]x , " + " output logic[a - b: c] yy ) ;endmodule:foo\n", + "module foo (\n" + " input [ a:c] x,\n" // aligned + " output logic [a - b:c] yy\n" + ");\n" + "endmodule : foo\n"}, + {"module foo( input [a:c]x , input zzz ," + " output logic[a - b: c] yy ) ;endmodule:foo\n", + "module foo (\n" + " input [ a:c] x,\n" // aligned []'s + " input zzz,\n" // aligned ids + " output logic [a - b:c] yy\n" + ");\n" + "endmodule : foo\n"}, + {"module foo( input [a:b]x , " + " output reg[e: f] yy ) ;endmodule:foo\n", + "module foo (\n" + " input [a:b] x,\n" // aligned + " output reg [e:f] yy\n" + ");\n" + "endmodule : foo\n"}, + {"module foo( input tri[aa: bb]x , " + " output reg[e: f] yy ) ;endmodule:foo\n", + "module foo (\n" + " input tri [aa:bb] x,\n" // aligned + " output reg [ e:f] yy\n" // TODO(b/70310743): align ':' + ");\n" + "endmodule : foo\n"}, + {"module foo( input [a:b][c:d]x , " + " output reg[e: f] yy ) ;endmodule:foo\n", + "module foo (\n" + " input [a:b][c:d] x,\n" // aligned + " output reg [e:f] yy\n" + ");\n" + "endmodule : foo\n"}, + {"module foo( input wire x [j:k], output reg yy ) ;endmodule:foo\n", + "module foo (\n" + " input wire x [j:k],\n" // aligned + " output reg yy\n" + ");\n" + "endmodule : foo\n"}, + {"module foo( input wire x , output reg yy [j:k]) ;endmodule:foo\n", + "module foo (\n" + " input wire x,\n" // aligned + " output reg yy[j:k]\n" + ");\n" + "endmodule : foo\n"}, + {"module foo( input wire x [p:q], output reg yy [j:k]) ;endmodule:foo\n", + "module foo (\n" + " input wire x [p:q],\n" // aligned + " output reg yy[j:k]\n" + ");\n" + "endmodule : foo\n"}, + {"module foo( input wire x [p:q][r:s], output reg yy [j:k]) " + ";endmodule:foo\n", + "module foo (\n" + " input wire x [p:q][r:s],\n" // aligned + " output reg yy[j:k]\n" + ");\n" + "endmodule : foo\n"}, + {"module foo( input wire x [p:q][rr:ss], output reg yy [jj:kk][m:n]) " + ";endmodule:foo\n", + "module foo (\n" + // TODO(b/70310743): align :'s + " input wire x [ p:q][rr:ss],\n" + " output reg yy[jj:kk][ m:n]\n" // aligned + ");\n" + "endmodule : foo\n"}, + {"module foo( input wire [p:q]x, output reg yy [j:k]) ;endmodule:foo\n", + "module foo (\n" + " input wire [p:q] x,\n" // aligned + " output reg yy[j:k]\n" + ");\n" + "endmodule : foo\n"}, + {"module foo( input wire x [p:q], output reg[j:k]yy) ;endmodule:foo\n", + "module foo (\n" + " input wire x [p:q],\n" // aligned + " output reg [j:k] yy\n" + ");\n" + "endmodule : foo\n"}, + {"module foo( input pkg::bar_t x , output reg yy) ;endmodule:foo\n", + "module foo (\n" + " input pkg::bar_t x,\n" // aligned + " output reg yy\n" + ");\n" + "endmodule : foo\n"}, + {"module foo( input wire x , output pkg::bar_t yy) ;endmodule:foo\n", + "module foo (\n" + " input wire x,\n" // aligned + " output pkg::bar_t yy\n" + ");\n" + "endmodule : foo\n"}, + {"module foo( input pkg::bar_t#(1) x , output reg yy) ;endmodule:foo\n", + "module foo (\n" // with parameterized port type + " input pkg::bar_t#(1) x,\n" + " output reg yy\n" // aligned + ");\n" + "endmodule : foo\n"}, + {"module foo( input signed x , output reg yy) ;endmodule:foo\n", + "module foo (\n" + " input signed x,\n" // aligned + " output reg yy\n" + ");\n" + "endmodule : foo\n"}, + {"module foo( input signed x , output reg [m:n] yy) ;endmodule:foo\n", + "module foo (\n" + " input signed x,\n" // aligned + " output reg [m:n] yy\n" + ");\n" + "endmodule : foo\n"}, + {"module foo( input int signed x , output reg [m:n] yy) ;endmodule:foo\n", + "module foo (\n" + " input int signed x,\n" // aligned + " output reg [m:n] yy\n" + ");\n" + "endmodule : foo\n"}, + {"module foo( input signed x , output pkg::bar_t yy) ;endmodule:foo\n", + "module foo (\n" + " input signed x,\n" // aligned + " output pkg::bar_t yy\n" + ");\n" + "endmodule : foo\n"}, + {"module somefunction (" + "logic clk, int a, int b);endmodule", + "module somefunction (\n" + " logic clk,\n" // direction missing + " int a,\n" // direction missing + " int b\n" // direction missing + ");\n" + "endmodule\n"}, + {"module somefunction (" + "logic clk, input int a, int b);endmodule", + "module somefunction (\n" + " logic clk,\n" // direction missing + " input int a,\n" + " int b\n" // direction missing + ");\n" + "endmodule\n"}, + {"module somefunction (" + "input logic clk, input int a, int b);endmodule", + "module somefunction (\n" + " input logic clk,\n" + " input int a,\n" + " int b\n" // direction missing + ");\n" + "endmodule\n"}, + {"module somefunction (" + "input clk, input int a, int b);endmodule", + "module somefunction (\n" + " input clk,\n" // type missing + " input int a,\n" + " int b\n" + ");\n" + "endmodule\n"}, + {"module somefunction (" + "input logic clk, input a, int b);endmodule", + "module somefunction (\n" + " input logic clk,\n" + " input a,\n" // type missing + " int b\n" // direction missing + ");\n" + "endmodule\n"}, + {"module t;\n" + " input bit i_bit;\n" + "input byte i_byte ;\n" + "input chandle i_chandle;\n" + "input event i_event;\n" + "input int i_int;\n" + "input integer i_inte;\n" + "input longint i_longint;\n" + "input real i_real;\n" + "input realtime i_realtime;\n" + "input shortint i_shortint;\n" + "input shortreal i_shortreal;\n" + "input string i_string;\n" + "input time i_time;\n" + " output bit o_bit;\n" + "output byte o_byte ; \n" + "output chandle o_chandle;\n" + "output event o_event;\n" + "output int o_int;\n" + "output integer o_inte;\n" + "output longint o_longint;\n" + "output real o_real;\n" + "output realtime o_realtime;\n" + "output shortint o_shortint;\n" + "output shortreal o_shortreal;\n" + "output string o_string;\n" + "output time o_time;\n" + "endmodule\n", + "module t;\n" + " input bit i_bit;\n" + " input byte i_byte;\n" + " input chandle i_chandle;\n" + " input event i_event;\n" + " input int i_int;\n" + " input integer i_inte;\n" + " input longint i_longint;\n" + " input real i_real;\n" + " input realtime i_realtime;\n" + " input shortint i_shortint;\n" + " input shortreal i_shortreal;\n" + " input string i_string;\n" + " input time i_time;\n" + " output bit o_bit;\n" + " output byte o_byte;\n" + " output chandle o_chandle;\n" + " output event o_event;\n" + " output int o_int;\n" + " output integer o_inte;\n" + " output longint o_longint;\n" + " output real o_real;\n" + " output realtime o_realtime;\n" + " output shortint o_shortint;\n" + " output shortreal o_shortreal;\n" + " output string o_string;\n" + " output time o_time;\n" + "endmodule\n"}, + {"module t (\n" + " input bit i_bit,\n" + "input byte i_byte ,\n" + "input chandle i_chandle,\n" + "input event i_event,\n" + "input int i_int,\n" + "input integer i_inte,\n" + "input longint i_longint,\n" + "input real i_real,\n" + "input realtime i_realtime,\n" + "input shortint i_shortint,\n" + "input shortreal i_shortreal,\n" + "input string i_string,\n" + "input time i_time,\n" + " output bit o_bit,\n" + "output byte o_byte , \n" + "output chandle o_chandle,\n" + "output event o_event,\n" + "output int o_int,\n" + "output integer o_inte,\n" + "output longint o_longint,\n" + "output real o_real,\n" + "output realtime o_realtime,\n" + "output shortint o_shortint,\n" + "output shortreal o_shortreal,\n" + "output string o_string,\n" + "output time o_time);\n" + "endmodule\n", + "module t (\n" + " input bit i_bit,\n" + " input byte i_byte,\n" + " input chandle i_chandle,\n" + " input event i_event,\n" + " input int i_int,\n" + " input integer i_inte,\n" + " input longint i_longint,\n" + " input real i_real,\n" + " input realtime i_realtime,\n" + " input shortint i_shortint,\n" + " input shortreal i_shortreal,\n" + " input string i_string,\n" + " input time i_time,\n" + " output bit o_bit,\n" + " output byte o_byte,\n" + " output chandle o_chandle,\n" + " output event o_event,\n" + " output int o_int,\n" + " output integer o_inte,\n" + " output longint o_longint,\n" + " output real o_real,\n" + " output realtime o_realtime,\n" + " output shortint o_shortint,\n" + " output shortreal o_shortreal,\n" + " output string o_string,\n" + " output time o_time\n" + ");\n" + "endmodule\n"}, + {"module m;foo bar(.baz({larry, moe, curly}));endmodule", + "module m;\n" + " foo bar (.baz({larry, moe, curly}));\n" + "endmodule\n"}, + {"module m;foo bar(.baz({larry,// expand this\n" + "moe, curly}));endmodule", + "module m;\n" + " foo bar (\n" + " .baz({\n" + " larry, // expand this\n" + " moe,\n" + " curly\n" + " })\n" + " );\n" + "endmodule\n"}, + {"parameter priv_reg_t impl_csr[] = {\n" + "// Machine mode mode CSR\n" + "MVENDORID, //\n" + "MARCHID, //\n" + "DSCRATCH0, //\n" + "DSCRATCH1 //\n" + "};", + "parameter priv_reg_t impl_csr[] = {\n" + " // Machine mode mode CSR\n" + " MVENDORID, //\n" + " MARCHID, //\n" + " DSCRATCH0, //\n" + " DSCRATCH1 //\n" + "};\n"}, + {"parameter priv_reg_t impl_csr[] = {\n" + "// Expand elements\n" + "MVENDORID,\n" + "MARCHID,\n" + "DSCRATCH0,\n" + "DSCRATCH1\n" + "};", + "parameter priv_reg_t impl_csr[] = {\n" + " // Expand elements\n" + " MVENDORID,\n" + " MARCHID,\n" + " DSCRATCH0,\n" + " DSCRATCH1\n" + "};\n"}, + /* TODO(b/158131099): to fix these, reinterpret 'b' as a kPortDeclaration + {"module somefunction (" + "input logic clk, input a, b);endmodule", + "module somefunction (\n" + " input logic clk,\n" + " input a,\n" // type missing + " b\n" // type and direction missing + ");\n" + "endmodule\n"}, + {"module somefunction (" + "input logic clk, int a, b);endmodule", + "module somefunction (\n" + " input logic clk,\n" + " int a,\n" // direction missing + " b\n" // type and direction missing + ");\n" + "endmodule\n"}, + */ + {"module foo(\n" + "//c1\n" + "input wire x , \n" + "//c2\n" + "output reg yy\n" + "//c3\n" + ") ;endmodule:foo\n", + "module foo (\n" + " //c1\n" + " input wire x,\n" // aligned, ignoring comments + " //c2\n" + " output reg yy\n" + " //c3\n" + ");\n" + "endmodule : foo\n"}, + {"module foo(\n" + "//c1\n" + "input wire x , \n" + "//c2a\n" // longer comment + "//c2b\n" + "output reg yy\n" + "//c3\n" + ") ;endmodule:foo\n", + "module foo (\n" + " //c1\n" + " input wire x,\n" // aligned, ignoring comments + " //c2a\n" // note: separated by 2 lines of comments + " //c2b\n" + " output reg yy\n" + " //c3\n" + ");\n" + "endmodule : foo\n"}, + {"module foo(\n" + "`ifdef FOO\n" + "input wire x , \n" + " `else\n" + "output reg yy\n" + " `endif\n" + ") ;endmodule:foo\n", + "module foo (\n" + "`ifdef FOO\n" + " input wire x,\n" // aligned, ignoring preprocessor conditionals + "`else\n" + " output reg yy\n" + "`endif\n" + ");\n" + "endmodule : foo\n"}, + {"module foo(\n" + "input w , \n" + "`define FOO BAR\n" + "input wire x , \n" + " `include \"stuff.svh\"\n" + "output reg yy\n" + " `undef FOO\n" + "output zz\n" + ") ;endmodule:foo\n", + "module foo (\n" + " input w,\n" // aligned, ignoring preprocessor directives + " `define FOO BAR\n" + " input wire x,\n" + " `include \"stuff.svh\"\n" + " output reg yy\n" + " `undef FOO\n" + " output zz\n" // aligned, ignoring preprocessor directives + ");\n" + "endmodule : foo\n"}, + {"module foo(\n" + "input wire x , \n \n" // blank line, separating alignment groups + "output reg yy\n" + ") ;endmodule:foo\n", + "module foo (\n" + " input wire x,\n" // not aligned, due to blank line separating groups + "\n" + " output reg yy\n" + ");\n" + "endmodule : foo\n"}, + {"module foo(\n" + "input wire x1 [r:s],\n" + "input [p:q] x2 , \n \n" // blank line, separating alignment groups + "output reg [jj:kk]yy1,\n" + "output pkg::barr_t [mm:nn] yy2\n" + ") ;endmodule:foo\n", + "module foo (\n" + " input wire x1[r:s],\n" // aligned in this group, but not across + // groups + " input [p:q] x2,\n" + "\n" + " output reg [jj:kk] yy1,\n" + " output pkg::barr_t [mm:nn] yy2\n" + ");\n" + "endmodule : foo\n"}, + {"module foo(\n" // same as previous, with comments + " //c1\n" + "input wire x1 [r:s],\n" + "input [p:q] x2 , \n" + " //c2\n\n" // blank line, separating alignment groups + " //c3\n" + "output reg [jj:kk]yy1,\n" + " //c4\n" + "output pkg::barr_t [mm:nn] yy2\n" + ") ;endmodule:foo\n", + "module foo (\n" + " //c1\n" + " input wire x1[r:s],\n" // aligned in this group, but not across + // groups + " input [p:q] x2,\n" + " //c2\n" + "\n" + " //c3\n" + " output reg [jj:kk] yy1,\n" + " //c4\n" + " output pkg::barr_t [mm:nn] yy2\n" + ");\n" + "endmodule : foo\n"}, + + {// align null-statement (issue #824) + "class sample;" + "bit a;;" + "bit b;" + "endclass", + "class sample;\n" + " bit a;\n" + " ;\n" + " bit b;\n" + "endclass\n"}, + {"class sample;" + "bit a;;" + "endclass", + "class sample;\n" + " bit a;\n" + " ;\n" + "endclass\n"}, + {"class sample;" + "bit a;" + "bit b;;" + "endclass", + "class sample;\n" + " bit a;\n" + " bit b;\n" + " ;\n" + "endclass\n"}, + + {// aligning here just barely fits in the 40col limit + "module foo( input int signed x [a:b]," + "output reg [mm:nn] yy) ;endmodule:foo\n", + "module foo (\n" + // ---------------40col-----------------> + " input int signed x [a:b],\n" // aligned, still fits + " output reg [mm:nn] yy\n" + ");\n" + "endmodule : foo\n"}, + {// when aligning would result in exceeding column limit, don't align for + // now + "module foo( input int signed x [aa:bb]," + "output reg [mm:nn] yy) ;endmodule:foo\n", + "module foo (\n" + // ---------------40col-----------------> + // input int signed x [aa:bb],\n" + // output reg [mm:nn] yy\n" + " input int signed x [aa:bb],\n" // aligned, still fits + " output reg [mm:nn] yy\n" + ");\n" + "endmodule : foo\n"}, + {// when aligning would result in exceeding column limit, don't align for + // now + "module foo( input int signed x [aa:bb]," + "output reg [mm:nn] yyy) ;endmodule:foo\n", + "module foo (\n" + // ---------------40col-----------------> + // input int signed x [aa:bb],\n" // over limit, by comma + // output reg [mm:nn] yyy\n" + " input int signed x[aa:bb],\n" // aligned would be 41 columns + " output reg [mm:nn] yyy\n" + ");\n" + "endmodule : foo\n"}, + {// when aligning would result in exceeding column limit, don't align for + // now + "module foo( input int signed x [a:b],//c\n" + "output reg [m:n] yy) ;endmodule:foo\n", + "module foo (\n" + // ---------------40col----------------> + // input int signed x [a:b], //c\n" // over limit, by comment + // output reg [m:n] yy\n" + " input int signed x[a:b], //c\n" // aligned would be 42 columns + " output reg [m:n] yy\n" + ");\n" + "endmodule : foo\n"}, + {// aligning interfaces in port headers like types + // TODO(b/161181877): flush interface port type left (multi-column) + "module foo( input clk , inter.face yy) ;endmodule:foo\n", + "module foo (\n" + " input clk,\n" // aligned + " inter.face yy\n" + ");\n" + "endmodule : foo\n"}, + {// aligning interfaces in port headers like types + // TODO(b/161181877): flush interface port type left (multi-column) + "module foo( input wire clk , inter.face yy) ;endmodule:foo\n", + "module foo (\n" + " input wire clk,\n" // aligned + " inter.face yy\n" + ");\n" + "endmodule : foo\n"}, + + // module local variable/net declaration alignment test cases + {"module m;\n" + "logic a;\n" + "bit b;\n" + "endmodule\n", + "module m;\n" + " logic a;\n" + " bit b;\n" + "endmodule\n"}, + {"module m;\n" + "logic a;\n" + "bit b;\n" + "initial e=f;\n" // separates alignment groups + "wire c;\n" + "bit d;\n" + "endmodule\n", + "module m;\n" + " logic a;\n" + " bit b;\n" + " initial e = f;\n" // separates alignment groups + " wire c;\n" + " bit d;\n" + "endmodule\n"}, + {"module m;\n" + "// hello a\n" + "logic a;\n" + "// hello b\n" + "bit b;\n" + "endmodule\n", + "module m;\n" + " // hello a\n" + " logic a;\n" + " // hello b\n" + " bit b;\n" // aligned across comments + "endmodule\n"}, + {"module m;\n" + "// hello a\n" + "logic a;\n" + "\n" // extra blank line + "// hello b\n" + "bit b;\n" + "endmodule\n", + "module m;\n" + " // hello a\n" + " logic a;\n" + "\n" // extra blank line + " // hello b\n" // aligned across blank lines + " bit b;\n" // aligned across comments + "endmodule\n"}, + {"module m;\n" + "logic [x:y]a;\n" // packed dimensions + "bit b;\n" + "endmodule\n", + "module m;\n" + " logic [x:y] a;\n" + " bit b;\n" + "endmodule\n"}, + {"module m;\n" + "logic a;\n" + "bit [pp:qq]b;\n" // packed dimensions + "endmodule\n", + "module m;\n" + " logic a;\n" + " bit [pp:qq] b;\n" + "endmodule\n"}, + {"module m;\n" + "logic [x:y]a;\n" // packed dimensions + "bit [pp:qq]b;\n" // packed dimensions + "endmodule\n", + "module m;\n" + " logic [ x:y] a;\n" + " bit [pp:qq] b;\n" + "endmodule\n"}, + {"module m;\n" + "logic [x:y]a;\n" // packed dimensions + "wire [pp:qq] [e:f]b;\n" // packed dimensions, 2D + "endmodule\n", + "module m;\n" + " logic [ x:y] a;\n" + " wire [pp:qq][e:f] b;\n" + "endmodule\n"}, + {"module m;\n" + "logic a [x:y];\n" // unpacked dimensions + "bit bbb;\n" + "endmodule\n", + "module m;\n" + " logic a [x:y];\n" + " bit bbb;\n" + "endmodule\n"}, + {"module m;\n" + "logic aaa ;\n" + "wire w [yy:zz];\n" // unpacked dimensions + "endmodule\n", + "module m;\n" + " logic aaa;\n" + " wire w [yy:zz];\n" + "endmodule\n"}, + {"module m;\n" + "logic aaa [s:t] ;\n" // unpacked dimensions + "wire w [yy:zz];\n" // unpacked dimensions + "endmodule\n", + "module m;\n" + " logic aaa[ s:t];\n" + " wire w [yy:zz];\n" + "endmodule\n"}, + {"module m;\n" + "logic aaa [s:t] ;\n" // unpacked dimensions + "wire w [yy:zz][u:v];\n" // unpacked dimensions, 2D + "endmodule\n", + "module m;\n" + " logic aaa[ s:t];\n" + " wire w [yy:zz] [u:v];\n" + // TODO(b/165323560): unwanted space between unpacked dimensions of 'w' + "endmodule\n"}, + {"module m;\n" + "qqq::rrr s;\n" // user-defined type + "wire [pp:qq]w;\n" // packed dimensions + "endmodule\n", + "module m;\n" + " qqq::rrr s;\n" + " wire [pp:qq] w;\n" + "endmodule\n"}, + {"module m;\n" + "qqq#(rr) s;\n" // parameterized type + "wire [pp:qq]w;\n" // packed dimensions + "endmodule\n", + "module m;\n" + " qqq #(rr) s;\n" + " wire [pp:qq] w;\n" + "endmodule\n"}, + {"module m;\n" + "logic a;\n" + "bit b;\n" + "my_module my_inst( );\n" // module instance separates alignment groups + "wire c;\n" + "bit d;\n" + "endmodule\n", + "module m;\n" + " logic a;\n" // these two are aligned + " bit b;\n" + " my_module my_inst ();\n" // module instance separates alignment groups + " wire c;\n" // these two are aligned + " bit d;\n" + "endmodule\n"}, + {"module m;\n" + "logic aaa = expr1;\n" + "bit b = expr2;\n" + "endmodule\n", + "module m;\n" + " logic aaa = expr1;\n" + " bit b = expr2;\n" // no alignment at '=' yet + "endmodule\n"}, + {"(* foo='{\"bar_.*\"} *)\n" // funny attribute + "module mattr;\n" + "(* attr1=\"value1\" *)\n" // attribute ignored + "ex_input_pins_t ex_input_pins;\n" + "(* attr2=\"value2\" *)\n" // attribute ignored + "ex_output_pins_t ex_output_pins;\n" + "(* attr3=\"value3\" *)\n" // attribute ignored + "ex wrap_ex ( );\n" + "endmodule\n", + "(* foo='{\"bar_.*\"} *)\n" + "module mattr;\n" + " (* attr1=\"value1\" *)\n" // indented + " ex_input_pins_t ex_input_pins;\n" // aligned + " (* attr2=\"value2\" *)\n" // indented + " ex_output_pins_t ex_output_pins;\n" + " (* attr3=\"value3\" *)\n" // indented + " ex wrap_ex ();\n" + "endmodule\n"}, + {"module mattr;\n" + "ex_input_pins_t ex_input_pins;\n" + "ex_output_pins_t ex_output_pins;\n" + "(* package_definition=\"ex_pkg\" *)\n" // attribute ignored + "ex wrap_ex (\n" + ".clk(ex_input_pins.clk),\n" + ".rst(ex_input_pins.rst),\n" + ".in(ex_input_pins.in)\n" + ");\n" + "endmodule\n", + "module mattr;\n" + " ex_input_pins_t ex_input_pins;\n" // aligned + " ex_output_pins_t ex_output_pins;\n" + " (* package_definition=\"ex_pkg\" *)\n" // indented + " ex wrap_ex (\n" + " .clk(ex_input_pins.clk),\n" + " .rst(ex_input_pins.rst),\n" + " .in (ex_input_pins.in)\n" // aligned + " );\n" + "endmodule\n"}, + {"module test;\n" + "bind entropy_src tlul_assert #(.EndpointType(\"Device\"))\n" + "tlul_assert_device (.clk_i, .rst_ni, .h2d(tl_i), .d2h(tl_o));\n" + "endmodule\n", + "module test;\n" + " bind entropy_src tlul_assert #(\n" + " .EndpointType(\"Device\")\n" + " ) tlul_assert_device (\n" + " .clk_i,\n" + " .rst_ni,\n" + " .h2d(tl_i),\n" + " .d2h(tl_o)\n" + " );\n" + "endmodule\n"}, + {"module test;\n" + "bind entropy_src tlul_assert #(.EndpointType(\"Device\"))\n" + "tlul_assert_device (.clk_i, .rst_ni,\n\n .h2d(tl_i),\n\n .d2h(tl_o));\n" + "endmodule\n", + "module test;\n" + " bind entropy_src tlul_assert #(\n" + " .EndpointType(\"Device\")\n" + " ) tlul_assert_device (\n" + " .clk_i,\n" + " .rst_ni,\n" + "\n" + " .h2d(tl_i),\n" + "\n" + " .d2h(tl_o)\n" + " );\n" + "endmodule\n"}, + {"bind expand_me long_name #(.W(W_CONST), .D(D_CONST)) instaaance_name (" + ".in(iiiiiiiin),\n\n .out(ooooooout),\n .clk(ccccccclk),\n\n" + ".in1234 (in),\n //c1\n .out1234(out),\n .clk1234(clk),);", + "bind expand_me long_name #(\n" + " .W(W_CONST),\n" + " .D(D_CONST)\n" + ") instaaance_name (\n" + " .in(iiiiiiiin),\n" + "\n" + " .out(ooooooout),\n" + " .clk(ccccccclk),\n" + "\n" + " .in1234 (in),\n" + " //c1\n" + " .out1234(out),\n" + " .clk1234(clk),\n" + ");\n"}, + {"initial // clock generation\n begin\n clk = 0;\n forever begin\n" + "#4ns clk = !clk;\n end\n end\n", + "initial // clock generation\n" + " begin\n" + " clk = 0;\n" + " forever begin\n" + " #4ns clk = !clk;\n" + " end\n" + " end\n"}, + {"module foo #(int x,int y) ;endmodule:foo\n", // parameters + "module foo #(\n" + " int x,\n" + " int y\n" + ");\n" // each parameter on its own line + "endmodule : foo\n"}, + {"module foo #(int x)(input y) ;endmodule:foo\n", + // parameter and port + "module foo #(\n" + " int x\n" + ") (\n" + " input y\n" + ");\n" // each paramater and port item should be on its own line + "endmodule : foo\n"}, + {"module foo #(parameter int x,parameter int y) ;endmodule:foo\n", + // parameters don't fit (also should be on its own line) + "module foo #(\n" + " parameter int x,\n" + " parameter int y\n" + ");\n" + "endmodule : foo\n"}, + {"module foo #(parameter int xxxx,parameter int yyyy) ;endmodule:foo\n", + // parameters don't fit + "module foo #(\n" + " parameter int xxxx,\n" + " parameter int yyyy\n" + ");\n" + "endmodule : foo\n"}, + {"module foo #(parameter int x = $clog2 (N) ,parameter int y ) " + ";endmodule:foo\n", + // parameters don't fit + "module foo #(\n" + " parameter int x = $clog2(N),\n" // no space after $clog2 + " parameter int y\n" + ");\n" + "endmodule : foo\n"}, + {"module foo #(//comment\n" + "parameter bar =1,\n" + "localparam baz =2" + ") ();" + "endmodule", + "module foo #( //comment\n" + " parameter bar = 1,\n" + " localparam baz = 2\n" + ") ();\n" + "endmodule\n"}, + {"module foo #(" + "parameter bar =1,//comment\n" + "localparam baz =2" + ") ();" + "endmodule", + "module foo #(\n" + " parameter bar = 1, //comment\n" + " localparam baz = 2\n" + ") ();\n" + "endmodule\n"}, + {"module foo #(" + "parameter bar =1," + "localparam baz =2//comment\n" + ") ();" + "endmodule", + "module foo #(\n" + " parameter bar = 1,\n" + " localparam baz = 2 //comment\n" + ") ();\n" + "endmodule\n"}, + {"module foo #(" + "parameter bar =1//comment\n" + ",localparam baz =2\n" + ") ();" + "endmodule", + "module foo #(\n" + " parameter bar = 1 //comment\n" + " , localparam baz = 2\n" + ") ();\n" + "endmodule\n"}, + {"module foo;" + // fit in one line + "parameter int i = '{\n" + "1,\n" + "2,\n" + "3\n" + "};\n" + "endmodule", + "module foo;\n" + " parameter int i = '{1, 2, 3};\n" + "endmodule\n"}, + {"module foo;" + // too long for one line, expand + "localparam logic [63:0] RC[24] = '{\n" + "64'h 1,\n" + "64'h 2,\n" + "64'h 3\n" + "};\n" + "endmodule", + "module foo;\n" + " localparam logic [63:0] RC[24] = '{\n" + " 64'h1,\n" + " 64'h2,\n" + " 64'h3\n" + " };\n" + "endmodule\n"}, + {"module foo;" + "parameter int i = '{\n" + // force expansion + "1, //\n" + "2,\n" + "3\n" + "};\n" + "endmodule", + "module foo;\n" + " parameter int i = '{\n" + " 1, //\n" + " 2,\n" + " 3\n" + " };\n" + "endmodule\n"}, + {"module foo;" + "localparam logic [63:0] RC[24] = '{\n" + "64'h 0000_0000_0000_0001, // 0\n" + "64'h 0000_0000_0000_8082, // 1\n" + "64'h 8000_0000_8000_8008 // 23\n" + "};\n" + "endmodule", + "module foo;\n" + " localparam logic [63:0] RC[24] = '{\n" + " 64'h0000_0000_0000_0001, // 0\n" + " 64'h0000_0000_0000_8082, // 1\n" + " 64'h8000_0000_8000_8008 // 23\n" + " };\n" + "endmodule\n"}, + {"module foo;" + // nest two patterns + "parameter logic [11:0] i = '{\n" + "'{1,2,3},\n" + "'{1,2,3}\n" + "};\n" + "endmodule", + "module foo;\n" + " parameter logic [11:0] i = '{\n" + " '{1, 2, 3},\n" + " '{1, 2, 3}\n" + " };\n" + "endmodule\n"}, + {"module foo;" + // nest two patterns, expand interior + "parameter logic [11:0] i = '{\n" + "'{1, //\n" + " 2,3},\n" + "'{1,2,3}\n" + "};\n" + "endmodule", + "module foo;\n" + " parameter logic [11:0] i = '{\n" + " '{\n" + " 1, //\n" + " 2,\n" + " 3\n" + " },\n" + " '{1, 2, 3}\n" + " };\n" + "endmodule\n"}, + {"module foo;" + // nest two patterns, expand both + "parameter nest [2] i = '{\n" + "'{first : 32'h0000_0001,\n" + " second : 32'h0000_0011,\n" + " third: 32'h0000_0111},\n" + "'{first : 32'h1000_0001,\n" + " second : 32'h1000_0011,\n" + " third: 32'h1000_0111}\n" + "};\n" + "endmodule", + "module foo;\n" + " parameter nest [2] i = '{\n" + " '{\n" + " first : 32'h0000_0001,\n" + " second : 32'h0000_0011,\n" + " third: 32'h0000_0111\n" + " },\n" + " '{\n" + " first : 32'h1000_0001,\n" + " second : 32'h1000_0011,\n" + " third: 32'h1000_0111\n" + " }\n" + " };\n" + "endmodule\n"}, + {"module foo;" + // nest three patterns + "parameter logic [11:0] i = '{\n" + "'{'{1,2,3},4}\n" + "};\n" + "endmodule", + "module foo;\n" + " parameter logic [11:0] i = '{\n" + " '{'{1, 2, 3}, 4}\n" + " };\n" + "endmodule\n"}, + {"module foo;" + // nest three patterns, expand interior + "parameter logic [11:0] i = '{\n" + "'{\n" + "'{first : 32'h0000_0001,\n" + " second : 32'h0000_0011,\n" + " third: 32'h0000_0111},\n" + " 4},\n" + " 5,\n" + " '{1,2,3}\n" + "};\n" + "endmodule", + "module foo;\n" + " parameter logic [11:0] i = '{\n" + " '{\n" + " '{\n" + " first : 32'h0000_0001,\n" + " second : 32'h0000_0011,\n" + " third: 32'h0000_0111\n" + " },\n" + " 4\n" + " },\n" + " 5,\n" + " '{1, 2, 3}\n" + " };\n" + "endmodule\n"}, + {"module top;" + "foo#( \"test\" ) foo( );" + "bar#( \"test\" ,5) bar( );" + "endmodule\n", + "module top;\n" + " foo #(\"test\") foo ();\n" // module instantiation, string arg + " bar #(\"test\", 5) bar ();\n" + "endmodule\n"}, + {"module top;" + "foo#( `\"test`\" ) foo( );" + "bar#( `\"test`\" ,5) bar( );" + "endmodule\n", + "module top;\n" + " foo #(`\"test`\") foo ();\n" // module instantiation, eval string arg + " bar #(`\"test`\", 5) bar ();\n" + "endmodule\n"}, + {"`ifdef FOO\n" + " module bar;endmodule\n" + "`endif\n", + "`ifdef FOO\n" + "module bar;\n" + "endmodule\n" + "`endif\n"}, + {"`ifdef FOO\n" + " module bar;endmodule\n" + "`else module baz;endmodule\n" + "`endif\n", + "`ifdef FOO\n" + "module bar;\n" + "endmodule\n" + "`else\n" + "module baz;\n" + "endmodule\n" + "`endif\n"}, + {"`ifdef FOO\n" + " module bar;endmodule\n" + "`else /* glue me */ module baz;endmodule\n" + "`endif\n", + "`ifdef FOO\n" + "module bar;\n" + "endmodule\n" + "`else /* glue me */\n" + "module baz;\n" + "endmodule\n" + "`endif\n"}, + {"`ifdef FOO\n" + " module bar;endmodule\n" + "`else// different unit\n" + " module baz;endmodule\n" + "`endif\n", + "`ifdef FOO\n" + "module bar;\n" + "endmodule\n" + "`else // different unit\n" + "module baz;\n" + "endmodule\n" + "`endif\n"}, + + // unary: + - ! ~ & | ^ ~& ~| ~^ ^~ + {"module m;foo bar(.x(-{a,b}));endmodule", + "module m;\n" + " foo bar (.x(-{a, b}));\n" + "endmodule\n"}, + {"module m;foo bar(.x(!{a,b}));endmodule", + "module m;\n" + " foo bar (.x(!{a, b}));\n" + "endmodule\n"}, + {"module m;foo bar(.x(~{a,b}));endmodule", + "module m;\n" + " foo bar (.x(~{a, b}));\n" + "endmodule\n"}, + {"module m;foo bar(.x(&{a,b}));endmodule", + "module m;\n" + " foo bar (.x(&{a, b}));\n" + "endmodule\n"}, + {"module m;foo bar(.x(|{a,b}));endmodule", + "module m;\n" + " foo bar (.x(|{a, b}));\n" + "endmodule\n"}, + {"module m;foo bar(.x(^{a,b}));endmodule", + "module m;\n" + " foo bar (.x(^{a, b}));\n" + "endmodule\n"}, + {"module m;foo bar(.x(~&{a,b}));endmodule", + "module m;\n" + " foo bar (.x(~&{a, b}));\n" + "endmodule\n"}, + {"module m;foo bar(.x(~|{a,b}));endmodule", + "module m;\n" + " foo bar (.x(~|{a, b}));\n" + "endmodule\n"}, + {"module m;foo bar(.x(~^{a,b}));endmodule", + "module m;\n" + " foo bar (.x(~^{a, b}));\n" + "endmodule\n"}, + {"module m;foo bar(.x(^~{a,b}));endmodule", + "module m;\n" + " foo bar (.x(^~{a, b}));\n" + "endmodule\n"}, + + // binary: + - * / % & | ^ ^~ ~^ && || + {"module m;foo bar(.x(a+b));endmodule", + "module m;\n" + " foo bar (.x(a + b));\n" + "endmodule\n"}, + {"module m;foo bar(.x(a-b));endmodule", + "module m;\n" + " foo bar (.x(a - b));\n" + "endmodule\n"}, + {"module m;foo bar(.x(a*b));endmodule", + "module m;\n" + " foo bar (.x(a * b));\n" + "endmodule\n"}, + {"module m;foo bar(.x(a/b));endmodule", + "module m;\n" + " foo bar (.x(a / b));\n" + "endmodule\n"}, + {"module m;foo bar(.x(a%b));endmodule", + "module m;\n" + " foo bar (.x(a % b));\n" + "endmodule\n"}, + {"module m;foo bar(.x(a&b));endmodule", + "module m;\n" + " foo bar (.x(a & b));\n" + "endmodule\n"}, + {"module m;foo bar(.x(a|b));endmodule", + "module m;\n" + " foo bar (.x(a | b));\n" + "endmodule\n"}, + {"module m;foo bar(.x(a^b));endmodule", + "module m;\n" + " foo bar (.x(a ^ b));\n" + "endmodule\n"}, + {"module m;foo bar(.x(a^~b));endmodule", + "module m;\n" + " foo bar (.x(a ^~ b));\n" + "endmodule\n"}, + {"module m;foo bar(.x(a~^b));endmodule", + "module m;\n" + " foo bar (.x(a ~^ b));\n" + "endmodule\n"}, + {"module m;foo bar(.x(a&&b));endmodule", + "module m;\n" + " foo bar (.x(a && b));\n" + "endmodule\n"}, + {"module m;foo bar(.x(a||b));endmodule", + "module m;\n" + " foo bar (.x(a || b));\n" + "endmodule\n"}, + + // {a} op {b} + {"module m;foo bar(.x({a}+{b}));endmodule", + "module m;\n" + " foo bar (.x({a} + {b}));\n" + "endmodule\n"}, + {"module m;foo bar(.x({a}-{b}));endmodule", + "module m;\n" + " foo bar (.x({a} - {b}));\n" + "endmodule\n"}, + {"module m;foo bar(.x({a}*{b}));endmodule", + "module m;\n" + " foo bar (.x({a} * {b}));\n" + "endmodule\n"}, + {"module m;foo bar(.x({a}/{b}));endmodule", + "module m;\n" + " foo bar (.x({a} / {b}));\n" + "endmodule\n"}, + {"module m;foo bar(.x({a}%{b}));endmodule", + "module m;\n" + " foo bar (.x({a} % {b}));\n" + "endmodule\n"}, + {"module m;foo bar(.x({a}&{b}));endmodule", + "module m;\n" + " foo bar (.x({a} & {b}));\n" + "endmodule\n"}, + {"module m;foo bar(.x({a}|{b}));endmodule", + "module m;\n" + " foo bar (.x({a} | {b}));\n" + "endmodule\n"}, + {"module m;foo bar(.x({a}^{b}));endmodule", + "module m;\n" + " foo bar (.x({a} ^ {b}));\n" + "endmodule\n"}, + {"module m;foo bar(.x({a}^~{b}));endmodule", + "module m;\n" + " foo bar (.x({a} ^~ {b}));\n" + "endmodule\n"}, + {"module m;foo bar(.x({a}~^{b}));endmodule", + "module m;\n" + " foo bar (.x({a} ~^ {b}));\n" + "endmodule\n"}, + {"module m;foo bar(.x({a}&&{b}));endmodule", + "module m;\n" + " foo bar (.x({a} && {b}));\n" + "endmodule\n"}, + {"module m;foo bar(.x({a}||{b}));endmodule", + "module m;\n" + " foo bar (.x({a} || {b}));\n" + "endmodule\n"}, + + // (a) op (b) + {"module m;foo bar(.x((a)+(b)));endmodule", + "module m;\n" + " foo bar (.x((a) + (b)));\n" + "endmodule\n"}, + {"module m;foo bar(.x((a)-(b)));endmodule", + "module m;\n" + " foo bar (.x((a) - (b)));\n" + "endmodule\n"}, + {"module m;foo bar(.x((a)*(b)));endmodule", + "module m;\n" + " foo bar (.x((a) * (b)));\n" + "endmodule\n"}, + {"module m;foo bar(.x((a)/(b)));endmodule", + "module m;\n" + " foo bar (.x((a) / (b)));\n" + "endmodule\n"}, + {"module m;foo bar(.x((a)%(b)));endmodule", + "module m;\n" + " foo bar (.x((a) % (b)));\n" + "endmodule\n"}, + {"module m;foo bar(.x((a)&(b)));endmodule", + "module m;\n" + " foo bar (.x((a) & (b)));\n" + "endmodule\n"}, + {"module m;foo bar(.x((a)|(b)));endmodule", + "module m;\n" + " foo bar (.x((a) | (b)));\n" + "endmodule\n"}, + {"module m;foo bar(.x((a)^(b)));endmodule", + "module m;\n" + " foo bar (.x((a) ^ (b)));\n" + "endmodule\n"}, + {"module m;foo bar(.x((a)^~(b)));endmodule", + "module m;\n" + " foo bar (.x((a) ^~ (b)));\n" + "endmodule\n"}, + {"module m;foo bar(.x((a)~^(b)));endmodule", + "module m;\n" + " foo bar (.x((a) ~^ (b)));\n" + "endmodule\n"}, + {"module m;foo bar(.x((a)&&(b)));endmodule", + "module m;\n" + " foo bar (.x((a) && (b)));\n" + "endmodule\n"}, + {"module m;foo bar(.x((a)||(b)));endmodule", + "module m;\n" + " foo bar (.x((a) || (b)));\n" + "endmodule\n"}, + + // a[b] op c + {"module m;foo bar(.x(a[b]+c));endmodule", + "module m;\n" + " foo bar (.x(a[b] + c));\n" + "endmodule\n"}, + {"module m;foo bar(.x(a[b]-c));endmodule", + "module m;\n" + " foo bar (.x(a[b] - c));\n" + "endmodule\n"}, + {"module m;foo bar(.x(a[b]*c));endmodule", + "module m;\n" + " foo bar (.x(a[b] * c));\n" + "endmodule\n"}, + {"module m;foo bar(.x(a[b]/c));endmodule", + "module m;\n" + " foo bar (.x(a[b] / c));\n" + "endmodule\n"}, + {"module m;foo bar(.x(a[b]%c));endmodule", + "module m;\n" + " foo bar (.x(a[b] % c));\n" + "endmodule\n"}, + {"module m;foo bar(.x(a[b]&c));endmodule", + "module m;\n" + " foo bar (.x(a[b] & c));\n" + "endmodule\n"}, + {"module m;foo bar(.x(a[b]|c));endmodule", + "module m;\n" + " foo bar (.x(a[b] | c));\n" + "endmodule\n"}, + {"module m;foo bar(.x(a[b]^c));endmodule", + "module m;\n" + " foo bar (.x(a[b] ^ c));\n" + "endmodule\n"}, + {"module m;foo bar(.x(a[b]^~c));endmodule", + "module m;\n" + " foo bar (.x(a[b] ^~ c));\n" + "endmodule\n"}, + {"module m;foo bar(.x(a[b]~^c));endmodule", + "module m;\n" + " foo bar (.x(a[b] ~^ c));\n" + "endmodule\n"}, + {"module m;foo bar(.x(a[b]&&c));endmodule", + "module m;\n" + " foo bar (.x(a[b] && c));\n" + "endmodule\n"}, + {"module m;foo bar(.x(a[b]||c));endmodule", + "module m;\n" + " foo bar (.x(a[b] || c));\n" + "endmodule\n"}, + + // misc + {"module m;foo bar(.x(a[1:0]^b[2:1]));endmodule", + "module m;\n" + " foo bar (.x(a[1:0] ^ b[2:1]));\n" + "endmodule\n"}, + + {"module m;foo bar(.x(a[b] | b[c]));endmodule", + "module m;\n" + " foo bar (.x(a[b] | b[c]));\n" + "endmodule\n"}, + {"module m;foo bar(.x(a[b] & b[c]));endmodule", + "module m;\n" + " foo bar (.x(a[b] & b[c]));\n" + "endmodule\n"}, + + {"module m;foo bar(.x((a^c)^(b^ ~c)));endmodule", + "module m;\n" + " foo bar (.x((a ^ c) ^ (b ^ ~c)));\n" + "endmodule\n"}, + {"module m;foo bar(.x((a^c)^(b^~c)));endmodule", + "module m;\n" + " foo bar (.x((a ^ c) ^ (b ^~ c)));\n" + "endmodule\n"}, + {"module m;foo bar(.x((a^{c,d})^(b^^{c,d})));endmodule", + "module m;\n" + " foo bar (\n" + " .x((a ^ {c, d}) ^ (b ^ ^{c, d}))\n" + " );\n" + "endmodule\n"}, + + {// module items mixed with preprocessor conditionals and comments + " module foo;\n" + "// comment1\n" + " `ifdef SIM\n" + "// comment2\n" + " `elsif SYN\n" + " // comment3\n" + " `else\n" + "// comment4\n" + " `endif\n" + "// comment5\n" + " endmodule", + "module foo;\n" + " // comment1\n" + "`ifdef SIM\n" + " // comment2\n" + "`elsif SYN\n" + " // comment3\n" + "`else\n" + " // comment4\n" + "`endif\n" + " // comment5\n" + "endmodule\n"}, + {" module bar;wire foo;reg bear;endmodule\n", + "module bar;\n" + " wire foo;\n" + " reg bear;\n" // aligned + "endmodule\n"}, + {" module bar;initial\nbegin a<=b . c ; end endmodule\n", + "module bar;\n" + " initial begin\n" + " a <= b.c;\n" + " end\n" + "endmodule\n"}, + {"module foo ();\nif (1) begin\n$finish(\n" + " 1 ); $finish ();\n end\nendmodule", + "module foo ();\n" + " if (1) begin\n" + " $finish(1);\n" + " $finish();\n" + " end\n" + "endmodule\n"}, + {" module bar;for(genvar i = 0 ; i<N ; ++ i ) begin end endmodule\n", + "module bar;\n" + " for (genvar i = 0; i < N; ++i) begin\n" + " end\n" + "endmodule\n"}, + {" module bar;for(genvar i = 0 ; i!=N ; i ++ ) begin " + "foo f;end endmodule\n", + "module bar;\n" + " for (genvar i = 0; i != N; i++) begin\n" + " foo f;\n" + " end\n" + "endmodule\n"}, + { + "module block_generate;\n" + "`ASSERT(blah)\n" + "generate endgenerate endmodule\n", + "module block_generate;\n" + " `ASSERT(blah)\n" + " generate\n" + " endgenerate\n" + "endmodule\n", + }, + { + "module conditional_generate;\n" + "if(foo) ; \t" // null action + "endmodule\n", + "module conditional_generate;\n" + " if (foo);\n" + "endmodule\n", + }, + { + "module conditional_generate;\n" + "if(foo[a*b+c]) ; \t" // null action + "endmodule\n", + "module conditional_generate;\n" + " if (foo[a*b+c]);\n" // allow compact expressions inside [] + "endmodule\n", + }, + { + "module conditional_generate;\n" + "if(foo)begin\n" + "`ASSERT()\n" + "`COVER()\n" + " end\n" + "endmodule\n", + "module conditional_generate;\n" + " if (foo) begin\n" + " `ASSERT()\n" + " `COVER()\n" + " end\n" + "endmodule\n", + }, + { + "module conditional_generate;\n" + "`ASSERT()\n" + "if(foo)begin\n" + " end\n" + "`COVER()\n" + "endmodule\n", + "module conditional_generate;\n" + " `ASSERT()\n" + " if (foo) begin\n" + " end\n" + " `COVER()\n" + "endmodule\n", + }, + { + "module conditional_generate;\n" + "if(foo)begin\n" + " // comment1\n" + " // comment2\n" + " end\n" + "endmodule\n", + "module conditional_generate;\n" + " if (foo) begin\n" + " // comment1\n" + " // comment2\n" + " end\n" + "endmodule\n", + }, + { + "module m ;" + "for(genvar i=0; ;)\n; " // null generate statement + "for(genvar j=0 ;; )\n; " // null generate statement + "endmodule", + "module m;\n" + " for (genvar i = 0;;);\n" + " for (genvar j = 0;;);\n" + "endmodule\n", + }, + { + "module m ;" + "for (genvar f = 0; f < N; f++) begin " + "assign x = y; assign y = z;" + "end endmodule", + "module m;\n" + " for (genvar f = 0; f < N; f++) begin\n" + " assign x = y;\n" + " assign y = z;\n" + " end\n" + "endmodule\n", + }, + { + // standalone genvar statement + "module m ;" + "genvar f;" + "for(f=0; f<N; f ++ )begin " + "end endmodule", + "module m;\n" + " genvar f;\n" + " for (f = 0; f < N; f++) begin\n" + " end\n" + "endmodule\n", + }, + { + // multiple arguments to genvar statement + "module m ;" + "genvar f, g;" + "for(f=0; f<N; f ++ )begin " + "end for(g=N; g>0; g -- )begin " + "end endmodule", + "module m;\n" + " genvar f, g;\n" + " for (f = 0; f < N; f++) begin\n" + " end\n" + " for (g = N; g > 0; g--) begin\n" + " end\n" + "endmodule\n", + }, + { + // multiple genvar statements + "module m ;" + "genvar f;" + "genvar g;" + "for(f=0; f<N; f ++ )begin " + "end for(g=N; g>0; g -- )begin " + "end endmodule", + "module m;\n" + " genvar f;\n" + " genvar g;\n" + " for (f = 0; f < N; f++) begin\n" + " end\n" + " for (g = N; g > 0; g--) begin\n" + " end\n" + "endmodule\n", + }, + { + "module event_control ;" + "always@ ( posedge clk )z<=y;" + "endmodule\n", + "module event_control;\n" + " always @(posedge clk) z <= y;\n" + "endmodule\n", + }, + { + "module always_if ;" + "always@ ( posedge clk ) if (expr) z<=y;" + "endmodule\n", + "module always_if;\n" + " always @(posedge clk)\n" // doesn't fit + " if (expr)\n" + " z <= y;\n" + "endmodule\n", + }, + { + "module always_if ;" + "always@* if (expr) z<=y;" + "endmodule\n", + "module always_if;\n" + " always @* if (expr) z <= y;\n" // fits + "endmodule\n", + }, + { + "module \talways_if_else ;" + "always@* if (expr) z<=y; else g<=0;" + "endmodule\n", + "module always_if_else;\n" + " always @*\n" + " if (expr) z <= y;\n" // fits + " else g <= 0;\n" // fits + "endmodule\n", + }, + { + "module \talways_if_else_if ;" + "always@* if (expr) z<=y; else if (w) g<=0;" + "endmodule\n", + "module always_if_else_if;\n" + " always @*\n" + " if (expr) z <= y;\n" // fits + " else if (w) g <= 0;\n" // fits + "endmodule\n", + }, + { + "module \talways_if_else_if_else ;" + "always@* if (expr) z<=y; else if (w) g<=0;else h<=1;" + "endmodule\n", + "module always_if_else_if_else;\n" + " always @*\n" + " if (expr) z <= y;\n" // fits + " else if (w) g <= 0;\n" // fits + " else h <= 1;\n" + "endmodule\n", + }, + { + "module m;\n" + "always @(b, c)" + " for (;;)\ts = y;" + "endmodule", + "module m;\n" + " always @(b, c) for (;;) s = y;\n" // fits + "endmodule\n", + }, + { + "module m;\n" + "always @(posedge clk)" + " for (i=0;i<k;++i)\ts = y;" + "endmodule", + "module m;\n" + " always @(posedge clk)\n" + " for (i = 0; i < k; ++i)\n" + " s = y;\n" + "endmodule\n", + }, + { + "module m;\n" + "always @(posedge clk)" + " repeat (jj+kk)\ts = y;" + "endmodule", + "module m;\n" + " always @(posedge clk)\n" + " repeat (jj + kk)\n" + " s = y;\n" + "endmodule\n", + }, + { + "module m;\n" + "always @(posedge clk)" + " foreach(jj[kk])\ts = y;" + "endmodule", + "module m;\n" + " always @(posedge clk)\n" + " foreach (jj[kk])\n" + " s = y;\n" + "endmodule\n", + }, + { + "module m;\n" + "always @(posedge clk)" + " while(jj[kk])\ts = y;" + "endmodule", + "module m;\n" + " always @(posedge clk)\n" + " while (jj[kk])\n" + " s = y;\n" + "endmodule\n", + }, + { + "module m;\n" + "always @(posedge clk)" + " do s=y;while(jj[kk]);\t" + "endmodule", + "module m;\n" + " always @(posedge clk)\n" + " do\n" + " s = y;\n" + " while (jj[kk]);\n" + "endmodule\n", + }, + { + "module m;\n" + "always @(posedge clk) \n" + " case(jj)\tS:s = y;endcase\t" + "endmodule", + "module m;\n" + " always @(posedge clk)\n" + " case (jj)\n" + " S: s = y;\n" + " endcase\n" + "endmodule\n", + }, + + { + "module always_if ;" + "always@ ( posedge clk ) if (expr) z<=y;" + "endmodule\n", + "module always_if;\n" + " always @(posedge clk)\n" // doesn't fit + " if (expr)\n" + " z <= y;\n" + "endmodule\n", + }, + { + "module always_if ;" + "always@* if (expr) z<=y;" + "endmodule\n", + "module always_if;\n" + " always @* if (expr) z <= y;\n" // fits + "endmodule\n", + }, + { + "module \talways_if_else ;" + "always@* if (expr) z<=y; else g<=0;" + "endmodule\n", + "module always_if_else;\n" + " always @*\n" + " if (expr) z <= y;\n" // fits + " else g <= 0;\n" // fits + "endmodule\n", + }, + { + "module \talways_if_else_if ;" + "always@* if (expr) z<=y; else if (w) g<=0;" + "endmodule\n", + "module always_if_else_if;\n" + " always @*\n" + " if (expr) z <= y;\n" // fits + " else if (w) g <= 0;\n" // fits + "endmodule\n", + }, + { + "module \talways_if_else_if_else ;" + "always@* if (expr) z<=y; else if (w) g<=0;else h<=1;" + "endmodule\n", + "module always_if_else_if_else;\n" + " always @*\n" + " if (expr) z <= y;\n" // fits + " else if (w) g <= 0;\n" // fits + " else h <= 1;\n" + "endmodule\n", + }, + { + "module m;\n" + "always @(b, c)" + " for (;;)\ts = y;" + "endmodule", + "module m;\n" + " always @(b, c) for (;;) s = y;\n" // fits + "endmodule\n", + }, + { + "module m;\n" + "always @(posedge clk)" + " for (i=0;i<k;++i)\ts = y;" + "endmodule", + "module m;\n" + " always @(posedge clk)\n" + " for (i = 0; i < k; ++i)\n" + " s = y;\n" + "endmodule\n", + }, + { + "module m;\n" + "always @(posedge clk)" + " repeat (jj+kk)\ts = y;" + "endmodule", + "module m;\n" + " always @(posedge clk)\n" + " repeat (jj + kk)\n" + " s = y;\n" + "endmodule\n", + }, + { + "module m;\n" + "always @(posedge clk)" + " foreach(jj[kk])\ts = y;" + "endmodule", + "module m;\n" + " always @(posedge clk)\n" + " foreach (jj[kk])\n" + " s = y;\n" + "endmodule\n", + }, + { + "module m;\n" + "always @(posedge clk)" + " while(jj[kk])\ts = y;" + "endmodule", + "module m;\n" + " always @(posedge clk)\n" + " while (jj[kk])\n" + " s = y;\n" + "endmodule\n", + }, + { + "module m;\n" + "always @(posedge clk)" + " do s=y;while(jj[kk]);\t" + "endmodule", + "module m;\n" + " always @(posedge clk)\n" + " do\n" + " s = y;\n" + " while (jj[kk]);\n" + "endmodule\n", + }, + { + "module m;\n" + "always @(posedge clk) \n" + " case(jj)\tS:s = y;endcase\t" + "endmodule", + "module m;\n" + " always @(posedge clk)\n" + " case (jj)\n" + " S: s = y;\n" + " endcase\n" + "endmodule\n", + }, + + { + "module always_if ;" + "always@ ( posedge clk ) if (expr) z<=y;" + "endmodule\n", + "module always_if;\n" + " always @(posedge clk)\n" // doesn't fit + " if (expr)\n" + " z <= y;\n" + "endmodule\n", + }, + { + "module always_if ;" + "always@* if (expr) z<=y;" + "endmodule\n", + "module always_if;\n" + " always @* if (expr) z <= y;\n" // fits + "endmodule\n", + }, + { + "module \talways_if_else ;" + "always@* if (expr) z<=y; else g<=0;" + "endmodule\n", + "module always_if_else;\n" + " always @*\n" + " if (expr) z <= y;\n" // fits + " else g <= 0;\n" // fits + "endmodule\n", + }, + { + "module \talways_if_else_if ;" + "always@* if (expr) z<=y; else if (w) g<=0;" + "endmodule\n", + "module always_if_else_if;\n" + " always @*\n" + " if (expr) z <= y;\n" // fits + " else if (w) g <= 0;\n" // fits + "endmodule\n", + }, + { + "module \talways_if_else_if_else ;" + "always@* if (expr) z<=y; else if (w) g<=0;else h<=1;" + "endmodule\n", + "module always_if_else_if_else;\n" + " always @*\n" + " if (expr) z <= y;\n" // fits + " else if (w) g <= 0;\n" // fits + " else h <= 1;\n" + "endmodule\n", + }, + { + "module m;\n" + "always @(b, c)" + " for (;;)\ts = y;" + "endmodule", + "module m;\n" + " always @(b, c) for (;;) s = y;\n" // fits + "endmodule\n", + }, + { + "module m;\n" + "always @(posedge clk)" + " for (i=0;i<k;++i)\ts = y;" + "endmodule", + "module m;\n" + " always @(posedge clk)\n" + " for (i = 0; i < k; ++i)\n" + " s = y;\n" + "endmodule\n", + }, + { + "module m;\n" + "always @(posedge clk)" + " repeat (jj+kk)\ts = y;" + "endmodule", + "module m;\n" + " always @(posedge clk)\n" + " repeat (jj + kk)\n" + " s = y;\n" + "endmodule\n", + }, + { + "module m;\n" + "always @(posedge clk)" + " foreach(jj[kk])\ts = y;" + "endmodule", + "module m;\n" + " always @(posedge clk)\n" + " foreach (jj[kk])\n" + " s = y;\n" + "endmodule\n", + }, + { + "module m;\n" + "always @(posedge clk)" + " while(jj[kk])\ts = y;" + "endmodule", + "module m;\n" + " always @(posedge clk)\n" + " while (jj[kk])\n" + " s = y;\n" + "endmodule\n", + }, + { + "module m;\n" + "always @(posedge clk)" + " do s=y;while(jj[kk]);\t" + "endmodule", + "module m;\n" + " always @(posedge clk)\n" + " do\n" + " s = y;\n" + " while (jj[kk]);\n" + "endmodule\n", + }, + { + "module m;\n" + "always @(posedge clk) \n" + " case(jj)\tS:s = y;endcase\t" + "endmodule", + "module m;\n" + " always @(posedge clk)\n" + " case (jj)\n" + " S: s = y;\n" + " endcase\n" + "endmodule\n", + }, + + { + "module always_if ;" + "always@ ( posedge clk ) if (expr) z<=y;" + "endmodule\n", + "module always_if;\n" + " always @(posedge clk)\n" // doesn't fit + " if (expr)\n" + " z <= y;\n" + "endmodule\n", + }, + { + "module always_if ;" + "always@* if (expr) z<=y;" + "endmodule\n", + "module always_if;\n" + " always @* if (expr) z <= y;\n" // fits + "endmodule\n", + }, + { + "module \talways_if_else ;" + "always@* if (expr) z<=y; else g<=0;" + "endmodule\n", + "module always_if_else;\n" + " always @*\n" + " if (expr) z <= y;\n" // fits + " else g <= 0;\n" // fits + "endmodule\n", + }, + { + "module \talways_if_else_if ;" + "always@* if (expr) z<=y; else if (w) g<=0;" + "endmodule\n", + "module always_if_else_if;\n" + " always @*\n" + " if (expr) z <= y;\n" // fits + " else if (w) g <= 0;\n" // fits + "endmodule\n", + }, + { + "module \talways_if_else_if_else ;" + "always@* if (expr) z<=y; else if (w) g<=0;else h<=1;" + "endmodule\n", + "module always_if_else_if_else;\n" + " always @*\n" + " if (expr) z <= y;\n" // fits + " else if (w) g <= 0;\n" // fits + " else h <= 1;\n" + "endmodule\n", + }, + { + "module m;\n" + "always @(b, c)" + " for (;;)\ts = y;" + "endmodule", + "module m;\n" + " always @(b, c) for (;;) s = y;\n" // fits + "endmodule\n", + }, + { + "module m;\n" + "always @(posedge clk)" + " for (i=0;i<k;++i)\ts = y;" + "endmodule", + "module m;\n" + " always @(posedge clk)\n" + " for (i = 0; i < k; ++i)\n" + " s = y;\n" + "endmodule\n", + }, + { + "module m;\n" + "always @(posedge clk)" + " repeat (jj+kk)\ts = y;" + "endmodule", + "module m;\n" + " always @(posedge clk)\n" + " repeat (jj + kk)\n" + " s = y;\n" + "endmodule\n", + }, + { + "module m;\n" + "always @(posedge clk)" + " foreach(jj[kk])\ts = y;" + "endmodule", + "module m;\n" + " always @(posedge clk)\n" + " foreach (jj[kk])\n" + " s = y;\n" + "endmodule\n", + }, + { + "module m;\n" + "always @(posedge clk)" + " while(jj[kk])\ts = y;" + "endmodule", + "module m;\n" + " always @(posedge clk)\n" + " while (jj[kk])\n" + " s = y;\n" + "endmodule\n", + }, + { + "module m;\n" + "always @(posedge clk)" + " do s=y;while(jj[kk]);\t" + "endmodule", + "module m;\n" + " always @(posedge clk)\n" + " do\n" + " s = y;\n" + " while (jj[kk]);\n" + "endmodule\n", + }, + { + "module m;\n" + "always @(posedge clk) \n" + " case(jj)\tS:s = y;endcase\t" + "endmodule", + "module m;\n" + " always @(posedge clk)\n" + " case (jj)\n" + " S: s = y;\n" + " endcase\n" + "endmodule\n", + }, + + { + // begin/end with labels + "module m ;initial begin:yyy\tend:yyy endmodule", + "module m;\n" + " initial begin : yyy\n" + " end : yyy\n" + "endmodule\n", + }, + { + // conditional generate begin/end with labels + "module m ;if\n( 1) begin:yyy\tend:yyy endmodule", + "module m;\n" + " if (1) begin : yyy\n" + " end : yyy\n" + "endmodule\n", + }, + { + // begin/end with labels, nested + "module m ;initial begin:yyy if(1)begin:zzz " + "end:zzz\tend:yyy endmodule", + "module m;\n" + " initial begin : yyy\n" + " if (1) begin : zzz\n" + " end : zzz\n" + " end : yyy\n" + "endmodule\n", + }, + { + "module m ;initial begin # 1 x<=y ;end endmodule", + "module m;\n" + " initial begin\n" + " #1 x <= y;\n" + " end\n" + "endmodule\n", + }, + { + "module m ;initial begin x<=y ; y<=z;end endmodule", + "module m;\n" + " initial begin\n" + " x <= y;\n" + " y <= z;\n" + " end\n" + "endmodule\n", + }, + { + "module m ;initial begin # 10 x<=y ; # 20 y<=z;end endmodule", + "module m;\n" + " initial begin\n" + " #10 x <= y;\n" + " #20 y <= z;\n" + " end\n" + "endmodule\n", + }, + { + // qualified variables + "module m ;initial begin automatic int a; " + " static byte s=0;end endmodule", + "module m;\n" + " initial begin\n" + " automatic int a;\n" + " static byte s = 0;\n" // aligned + " end\n" + "endmodule\n", + }, + { + "module m ;initial begin automatic int a,b; " + " static byte s,t;end endmodule", + "module m;\n" + " initial begin\n" + " automatic int a, b;\n" + " static byte s, t;\n" + " end\n" + "endmodule\n", + }, + { + "module m ;initial begin static byte a=1,b=0;end endmodule", + "module m;\n" + " initial begin\n" + " static byte a = 1, b = 0;\n" + " end\n" + "endmodule\n", + }, + { + "module m ;initial begin const int a=0;end endmodule", + "module m;\n" + " initial begin\n" + " const int a = 0;\n" + " end\n" + "endmodule\n", + }, + { + "module m ;initial begin automatic const int a=0;end endmodule", + "module m;\n" + " initial begin\n" + " automatic const int a = 0;\n" + " end\n" + "endmodule\n", + }, + { + "module m ;initial begin const var automatic int a=0;end endmodule", + "module m;\n" + " initial begin\n" + " const var automatic int a = 0;\n" + " end\n" + "endmodule\n", + }, + { + "module m ;initial begin static byte s ={<<{a}};end endmodule", + "module m;\n" + " initial begin\n" + " static byte s = {<<{a}};\n" + " end\n" + "endmodule\n", + }, + { + "module m ;initial begin static int s ={>>4{a}};end endmodule", + "module m;\n" + " initial begin\n" + " static int s = {>>4{a}};\n" + " end\n" + "endmodule\n", + }, + { + "module m; final assert (expr ) ;endmodule", + "module m;\n" + " final assert (expr);\n" + "endmodule\n", + }, + { + "module m; final begin\tassert (expr ) ;end endmodule", + "module m;\n" + " final begin\n" + " assert (expr);\n" + " end\n" + "endmodule\n", + }, + { + "module m; final assume (expr ) ;endmodule", + "module m;\n" + " final assume (expr);\n" + "endmodule\n", + }, + { + "module m; final cover (expr ) ;endmodule", + "module m;\n" + " final cover (expr);\n" + "endmodule\n", + }, + { + // two consecutive clocking declarations in modules + " module mcd ; " + "clocking cb @( posedge clk);\t\tendclocking " + "clocking cb2 @ (posedge clk\n); endclocking endmodule", + "module mcd;\n" + " clocking cb @(posedge clk);\n" + " endclocking\n" + " clocking cb2 @(posedge clk);\n" + " endclocking\n" + "endmodule\n", + }, + { + // two consecutive clocking declarations in modules, with end labels + " module mcd ; " + "clocking cb @( posedge clk);\t\tendclocking: cb " + "clocking cb2 @ (posedge clk\n); endclocking :cb2 endmodule", + "module mcd;\n" + " clocking cb @(posedge clk);\n" + " endclocking : cb\n" + " clocking cb2 @(posedge clk);\n" + " endclocking : cb2\n" + "endmodule\n", + }, + { + // clocking declarations with ports in modules + " module mcd ; " + "clocking cb @ (posedge clk\n); input a; output b; endclocking " + "endmodule", + "module mcd;\n" + " clocking cb @(posedge clk);\n" + " input a;\n" + " output b;\n" + " endclocking\n" + "endmodule\n", + }, + { + // DPI import declarations in modules + "module mdi;" + "import \"DPI-C\" function int add(\n) ;" + "import \"DPI-C\"\t\tfunction int\nsleep( input int secs );" + "import \"DPI-C\"\t\tfunction int\nwake( input int secs, output bit " + "[2:0] z);" + "endmodule", + "module mdi;\n" + " import \"DPI-C\" function int add();\n" + " import \"DPI-C\" function int sleep(\n" + " input int secs\n" + " );\n" + " import \"DPI-C\" function int wake(\n" + " input int secs,\n" + " output bit [2:0] z\n" + " );\n" + "endmodule\n", + }, + { + // DPI export declarations in modules + "module m;" + "export \"DPI-C\" function get;" + "export \"DPI-C\" function mhpmcounter_get;\n" + "export \"DPI-C\"\t\tfunction int\nwake( input int secs, output bit " + "[2:0] z);" + "endmodule", + "module m;\n" + " export \"DPI-C\" function get;\n" + " export \"DPI-C\"\n" + " function mhpmcounter_get;\n" // doesn't fit in 40-col + " export \"DPI-C\" function int wake(\n" + " input int secs,\n" + " output bit [2:0] z\n" + " );\n" + "endmodule\n", + }, + {// Two consecutive EOL comments in kDPIImportItem + "import \"DPI-C\" context function void foo(\n" + " input bit first,\n" + " // c3\n" + " // c3+\n" + " input bit second\n" + ");\n", + "import \"DPI-C\" context\n" + " function void foo(\n" + " input bit first,\n" + " // c3\n" + " // c3+\n" + " input bit second\n" + ");\n"}, + {"export \"\" t;\n", "export \"\" t;\n"}, + {"import \"DPI-C\" context function void func(input bit impl_i," + "input bit op_i," + "input bit [5:0] mode_i," + "input bit [3:0][31:0] iv_i," + "input bit [2:0] key_len_i," + "input bit [7:0][31:0] key_i," + "input bit [7:0] data_i[]," + "output bit [7:0] data_o[]);", + "import \"DPI-C\" context\n" + " function void func(\n" + " input bit impl_i,\n" + " input bit op_i,\n" + " input bit [5:0] mode_i,\n" + " input bit [3:0][31:0] iv_i,\n" + " input bit [2:0] key_len_i,\n" + " input bit [7:0][31:0] key_i,\n" + " input bit [7:0] data_i [],\n" + " output bit [7:0] data_o []\n" + ");\n"}, + {// module with system task call w or w/o parentheses + "module m; initial begin #10 $display(\"foo\"); $display(\"bar\");" + "end endmodule", + "module m;\n" + " initial begin\n" + " #10 $display(\"foo\");\n" + " $display(\"bar\");\n" + " end\n" + "endmodule\n"}, + {// module with system task call + "module m; initial begin #10 $display; $display;" + "end endmodule", + "module m;\n" + " initial begin\n" + " #10 $display;\n" + " $display;\n" + " end\n" + "endmodule\n"}, + +}; + +TEST(FormatterEndToEndTest, ModuleFormatterTestCases) { + RunFormatterTestCases40(kModuleFormatterTestCases); +} + +} // namespace +} // namespace formatter +} // namespace verilog
diff --git a/verible/verilog/formatting/formatter_test.cc b/verible/verilog/formatting/formatter_test.cc index 9677489..894254f 100644 --- a/verible/verilog/formatting/formatter_test.cc +++ b/verible/verilog/formatting/formatter_test.cc
@@ -1,4 +1,4 @@ -// Copyright 2017-2020 The Verible Authors. +// Copyright 2017-2026 The Verible Authors. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. @@ -13,42 +13,24 @@ // limitations under the License. // Test cases in this file should be *insensitive* to wrapping penalties. -// Penalty-sensitive tests belong in formatter_tuning_test.cc. -// Methods for keeping tests penalty insensitive: -// * Short lines and partitions. Lines that fit need no wrapping. -// * Forced line breaks using //comments (reduce decision-making) +// Penalty-sensitive tests belong in formatter-tuning_test.cc. +// Thematic end-to-end cases live in sibling formatter_*_test.cc files. +// New GitHub-issue regressions belong in formatter_issue_regression_test.cc. #include "verible/verilog/formatting/formatter.h" -#include <cctype> -#include <cstddef> #include <memory> #include <sstream> -#include <string> #include <string_view> -#include <vector> #include "absl/log/die_if_null.h" #include "absl/status/status.h" -#include "absl/strings/match.h" -#include "absl/strings/str_split.h" -#include "gmock/gmock.h" #include "gtest/gtest.h" -#include "verible/common/formatting/align.h" -#include "verible/common/formatting/basic-format-style.h" -#include "verible/common/strings/display-utils.h" -#include "verible/common/strings/position.h" #include "verible/common/text/text-structure.h" -#include "verible/common/util/interval.h" #include "verible/common/util/logging.h" #include "verible/verilog/analysis/verilog-analyzer.h" #include "verible/verilog/formatting/format-style.h" - -#undef EXPECT_OK -#define EXPECT_OK(value) EXPECT_TRUE((value).ok()) - -#undef ASSERT_OK -#define ASSERT_OK(value) ASSERT_TRUE((value).ok()) +#include "verible/verilog/formatting/formatter-test-utils.h" namespace verilog { namespace formatter { @@ -63,12 +45,7 @@ static constexpr VerilogPreprocess::Config kDefaultPreprocess; using absl::StatusCode; -using testing::HasSubstr; -using verible::AlignmentPolicy; -using verible::IndentationStyle; -using verible::LineNumberSet; -// Tests that clean output passes. TEST(VerifyFormattingTest, NoError) { const std::string_view code("class c;endclass\n"); const std::unique_ptr<VerilogAnalyzer> analyzer = @@ -114,15 +91,6 @@ EXPECT_EQ(status.code(), StatusCode::kDataLoss); } -struct FormatterTestCase { - std::string_view input; - std::string_view expected; -}; - -static const LineNumberSet kEnableAllLines; - -// Test that the expected output is produced with the formatter using a custom -// FormatStyle. TEST(FormatterTest, FormatCustomStyleTest) { static constexpr FormatterTestCase kTestCases[] = { {"", ""}, @@ -146,20817 +114,18 @@ } } -static constexpr FormatterTestCase kFormatterTestCases[] = { +// Small smoke subset; thematic cases live in sibling formatter_*_test.cc files. +static constexpr FormatterTestCase kSmokeFormatterTestCases[] = { {"", ""}, {"\n", "\n"}, {"\n\n", "\n\n"}, {"\t//comment\n", "//comment\n"}, {"\t/*comment*/\n", "/*comment*/\n"}, {"\t/*multi-line\ncomment*/\n", "/*multi-line\ncomment*/\n"}, - // preprocessor test cases - {"`include \"path/to/file.vh\"\n", "`include \"path/to/file.vh\"\n"}, - {"`include `\"path/to/file.vh`\"\n", "`include `\"path/to/file.vh`\"\n"}, - {"`define FOO\n", "`define FOO\n"}, - {"`define FOO BAR\n", "`define FOO BAR\n"}, - {"`define FOO\n" - "`define BAR\n", - "`define FOO\n" - "`define BAR\n"}, - {"`define FOO_``BAR 1\n", "`define FOO_``BAR 1\n"}, - {"`define FOO_```BAR 1\n", "`define FOO_```BAR 1\n"}, - {"`define FOO ``BAR\n", "`define FOO ``BAR\n"}, - {"`define A``B``C 2\n", "`define A``B``C 2\n"}, - {"`define A(x)``y\n", "`define A(x) ``y\n"}, - {"`define FOO_``BAR\n", "`define FOO_``BAR\n"}, - {"`ifndef FOO\n" - "`endif // FOO\n", - "`ifndef FOO\n" - "`endif // FOO\n"}, - {"`ifndef FOO\n" - "`define BAR\n" - "`endif\n", - "`ifndef FOO\n" - "`define BAR\n" - "`endif\n"}, - {"`ifndef FOO\n" - "`define BAR\n\n" // one more blank line - "`endif\n", - "`ifndef FOO\n" - "`define BAR\n\n" - "`endif\n"}, - {"`define FOO \\\n" - " BAR\n", - "`define FOO \\\n" // TODO(b/72527558): right align '\'s to column limit - " BAR\n"}, - {"`define FOOOOOOOOOOOOOOOO \\\n" - " BAAAAAAAAAAAAAAAAR BAAAAAAAAAAAAAZ;\n", - "`define FOOOOOOOOOOOOOOOO \\\n" // macro text starts at '\' - " BAAAAAAAAAAAAAAAAR BAAAAAAAAAAAAAZ;\n"}, - {"`ifdef FOO\n" - " `fine()\n" - "`else\n" - " `error()\n" - "`endif\n", - "`ifdef FOO\n" - "`fine()\n" - "`else\n" - "`error()\n" - "`endif\n"}, - {"`ifdef FOO\n" - " `fine()\n" - "`else // trouble\n" - " `error()\n" - "`endif\n", - "`ifdef FOO\n" - "`fine()\n" - "`else // trouble\n" - "`error()\n" - "`endif\n"}, - {"`ifdef FOO\n" - " `fine()\n" - "`else /* trouble */\n" - " `error()\n" - "`endif\n", - "`ifdef FOO\n" - "`fine()\n" - "`else /* trouble */\n" - "`error()\n" - "`endif\n"}, - {" // lonely comment\n", "// lonely comment\n"}, - {" // first comment\n" - " // last comment\n", - "// first comment\n" - "// last comment\n"}, - {" // starting comment\n" - " `define FOO\n", - "// starting comment\n" - "`define FOO\n"}, - {" `define FOO\n" - " // trailing comment\n", - "`define FOO\n" - "// trailing comment\n"}, - {" `define FOO\n" - " // trailing comment 1\n" - " // trailing comment 2\n", - "`define FOO\n" - "// trailing comment 1\n" - "// trailing comment 2\n"}, - { - " `define FOO \\\n" // multiline macro definition - " 1\n", - "`define FOO \\\n" - " 1\n" // TODO(b/141517267): Reflowing macro definitions - }, - {"`define FOO \\\n" // multiline macro definition - " b\n", - "`define FOO \\\n" // no need to align '\' - " b\n"}, - {"`define FOO \\\n" // multiline macro definition - " a + \\\n" - " b\n", - "`define FOO \\\n" // preserve spacing before '\' - " a + \\\n" // to stay aligned with this one - " b\n"}, - {" // comment with backslash\\\n", "// comment with backslash\\\n"}, - {// macro with MacroArg tokens as arguments - "`FOOOOOO(\nbar1...\n,\nbar2...\n,\nbar3...\n,\nbar4\n)\n", - "`FOOOOOO(bar1..., bar2..., bar3...,\n" - " bar4)\n"}, - {// macro declaration exceeds line length limit - "`F_MACRO(looooooong_type if_it_fits_I_sits)\n", - "`F_MACRO(\n" - " looooooong_type if_it_fits_I_sits)\n"}, - {// macro call with not fitting arguments - "`MACRO_FFFFFFFFFFF(" - "type_a_aaaa,type_b_bbbbb," - "type_c_cccccc,type_d_dddddddd," - "type_e_eeeeeeee,type_f_ffff)\n", - "`MACRO_FFFFFFFFFFF(\n" - " type_a_aaaa, type_b_bbbbb,\n" - " type_c_cccccc, type_d_dddddddd,\n" - " type_e_eeeeeeee, type_f_ffff)\n"}, - {// nested macro call - "`MACRO_FFFFFFFFFFF( " - "`A(type_a_aaaa), `B(type_b_bbbbb), " - "`C(type_c_cccccc), `D(type_d_dddddddd), " - "`E(type_e_eeeeeeee), `F(type_f_ffff))\n", - "`MACRO_FFFFFFFFFFF(`A(type_a_aaaa),\n" - " `B(type_b_bbbbb),\n" - " `C(type_c_cccccc),\n" - " `D(type_d_dddddddd),\n" - " `E(type_e_eeeeeeee),\n" - " `F(type_f_ffff))\n"}, - {// two-level nested macro call - "`MACRO_FFFFFFFFFFF( " - "`A(type_a_aaaa, `B(type_b_bbbbb)), " - "`C(type_c_cccccc, `D(type_d_dddddddd)), " - "`E(type_e_eeeeeeee, `F(type_f_ffff)))\n", - "`MACRO_FFFFFFFFFFF(\n" - " `A(type_a_aaaa, `B(type_b_bbbbb)),\n" - " `C(type_c_cccccc,\n" - " `D(type_d_dddddddd)),\n" - " `E(type_e_eeeeeeee,\n" - " `F(type_f_ffff)))\n"}, - {// three-level nested macro call - "`MACRO_FFFFFFFFFFF(`A(type_a_aaaa," - "`B(type_b_bbbbb,`C(type_c_cccccc)))," - "`D(type_d_dddddddd,`E(type_e_eeeeeeee," - "`F(type_f_ffff))))\n", - "`MACRO_FFFFFFFFFFF(\n" - " `A(type_a_aaaa,\n" - " `B(type_b_bbbbb,\n" - " `C(type_c_cccccc))),\n" - " `D(type_d_dddddddd,\n" - " `E(type_e_eeeeeeee,\n" - " `F(type_f_ffff))))\n"}, - {// macro call with MacroArg tokens as arugments and with semicolon - "`FOOOOOO(\nbar1...\n,\nbar2...\n,\nbar3...\n,\nbar4\n);\n", - "`FOOOOOO(bar1..., bar2..., bar3...,\n" - " bar4);\n"}, - {// macro declaration exceeds line length limit and contains semicolon - "`F_MACRO(looooooong_type if_it_fits_I_sits);\n", - "`F_MACRO(\n" - " looooooong_type if_it_fits_I_sits);\n"}, - {// macro call with not fitting arguments and semicolon - "`MACRO_FFFFFFFFFFF(" - "type_a_aaaa,type_b_bbbbb," - "type_c_cccccc,type_d_dddddddd," - "type_e_eeeeeeee,type_f_ffff);\n", - "`MACRO_FFFFFFFFFFF(\n" - " type_a_aaaa, type_b_bbbbb,\n" - " type_c_cccccc, type_d_dddddddd,\n" - " type_e_eeeeeeee, type_f_ffff);\n"}, - {// nested macro call with semicolon - "`MACRO_FFFFFFFFFFF( " - "`A(type_a_aaaa), `B(type_b_bbbbb), " - "`C(type_c_cccccc), `D(type_d_dddddddd), " - "`E(type_e_eeeeeeee), `F(type_f_ffff));\n", - "`MACRO_FFFFFFFFFFF(`A(type_a_aaaa),\n" - " `B(type_b_bbbbb),\n" - " `C(type_c_cccccc),\n" - " `D(type_d_dddddddd),\n" - " `E(type_e_eeeeeeee),\n" - " `F(type_f_ffff));\n"}, - {// two-level nested macro call with semicolon - "`MACRO_FFFFFFFFFFF( " - "`A(type_a_aaaa, `B(type_b_bbbbb)), " - "`C(type_c_cccccc, `D(type_d_dddddddd)), " - "`E(type_e_eeeeeeee, `F(type_f_ffff)));\n", - "`MACRO_FFFFFFFFFFF(\n" - " `A(type_a_aaaa, `B(type_b_bbbbb)),\n" - " `C(type_c_cccccc,\n" - " `D(type_d_dddddddd)),\n" - " `E(type_e_eeeeeeee,\n" - " `F(type_f_ffff)));\n"}, - {// three-level nested macro call with semicolon - "`MACRO_FFFFFFFFFFF(`A(type_a_aaaa," - "`B(type_b_bbbbb,`C(type_c_cccccc)))," - "`D(type_d_dddddddd,`E(type_e_eeeeeeee," - "`F(type_f_ffff))));\n", - "`MACRO_FFFFFFFFFFF(\n" - " `A(type_a_aaaa,\n" - " `B(type_b_bbbbb,\n" - " `C(type_c_cccccc))),\n" - " `D(type_d_dddddddd,\n" - " `E(type_e_eeeeeeee,\n" - " `F(type_f_ffff))));\n"}, - {// macro call with no args - "`FOOOOOO()\n", "`FOOOOOO()\n"}, - {// macro call with no args and semicolon - "`FOOOOOO();\n", "`FOOOOOO();\n"}, - {// macro call with no args and semicolon separated by space - "`FOOOOOO() ;\n", "`FOOOOOO();\n"}, - {// macro call with comments in argument list - "`FOO(aa, //aa\nbb , // bb\ncc)\n", - "`FOO(aa, //aa\n" - " bb, // bb\n" - " cc)\n"}, - {// macro call with comment before first argument - "`FOO(//aa\naa, //bb\nbb , // cc\ncc)\n", - "`FOO( //aa\n" - " aa, //bb\n" - " bb, // cc\n" - " cc)\n"}, - {// macro call with argument including trailing EOL comment - "`FOO(aa, bb,//cc\ndd)\n", - "`FOO(aa, bb, //cc\n" - " dd)\n"}, - {// macro call with argument including EOL comment on own line - "`FOOOO(aa, bb,\n//cc\ndd)\n", - "`FOOOO(aa, bb,\n" - " //cc\n" - " dd)\n"}, - {" // leading comment\n" - " `define FOO \\\n" // multiline macro definition - "1\n" - " // trailing comment\n", - "// leading comment\n" - "`define FOO \\\n" - "1\n" // TODO(b/141517267): Reflowing macro definitions - "// trailing comment\n"}, - {// macro call after define - "`define FOO BAR\n" - " `FOO( bar )\n", - "`define FOO BAR\n" - "`FOO(bar)\n"}, - {// multiple argument macro call - " `FOO( bar , baz )\n", "`FOO(bar, baz)\n"}, - {// long macro call breaking - " `ASSERT_INIT(S, (D == 4 && K inside {0, 1}) ||" - " (D == 3 && K== 4))\n", - "`ASSERT_INIT(\n" - " S, (D == 4 && K inside {0, 1}) ||\n" - " (D == 3 && K == 4))\n"}, - {// long macro call breaking - " `AINIT(S, (D == 4 && K inside {0, 1}) ||" - " (D == 3 && K== 4))\n", - "`AINIT(S, (D == 4 && K inside {0, 1}) ||\n" - " (D == 3 && K == 4))\n"}, - {// long macro call breaking - " `ASSERT_INIT(S, D == 4 && K inside {0, 1})\n", - "`ASSERT_INIT(S,\n" - " D == 4 && K inside {0, 1})\n"}, - {// macro call in function - "function void foo( ); foo=`FOO( bar , baz ) ; endfunction\n", - "function void foo();\n" - " foo = `FOO(bar, baz);\n" - "endfunction\n"}, - {// nested macro call in function - "function void foo( ); foo=`FOO( `BAR ( baz ) ) ; endfunction\n", - "function void foo();\n" - " foo = `FOO(`BAR(baz));\n" - "endfunction\n"}, - {// macro call in class - "class foo; `FOO ( bar , baz ) ; endclass\n", - "class foo;\n" - " `FOO(bar, baz);\n" - "endclass\n"}, - {// nested macro call in class - "class foo; `FOO ( `BAR ( baz1 , baz2 ) ) ; endclass\n", - "class foo;\n" - " `FOO(`BAR(baz1, baz2));\n" - "endclass\n"}, - {// multi-line macro arg "aaaa..." should start on its own line, - // even if its first line would fit under the column limit - "`CHECK_FATAL(rd_tr,\n" - " aaaa == zzz;\n" - " ggg == vv::w;,\n" - " \"Failed to ..........\")\n", - "`CHECK_FATAL(rd_tr,\n" - " aaaa == zzz;\n" - " ggg == vv::w;,\n" - " \"Failed to ..........\")\n"}, - {// macro call nested with function call containing an ifdef - "`J(D(`ifdef e))\n", - "`J(D(\n" - " `ifdef e))\n"}, - - // `uvm macros indenting - { - // simple test case - "`uvm_object_utils_begin(aa)\n" - "`uvm_field_int(bb, UVM_DEFAULT)\n" - "`uvm_field_int(cc, UVM_DEFAULT)\n" - "`uvm_object_utils_end\n", - "`uvm_object_utils_begin(aa)\n" - " `uvm_field_int(bb, UVM_DEFAULT)\n" - " `uvm_field_int(cc, UVM_DEFAULT)\n" - "`uvm_object_utils_end\n", - }, - {// multiple uvm.*begin - uvm.*end ranges - "`uvm_object_utils_begin(aa)\n" - "`uvm_field_int(bb, UVM_DEFAULT)\n" - "`uvm_field_int(cc, UVM_DEFAULT)\n" - "`uvm_object_utils_end\n" - "`uvm_field_int(bb, UVM_DEFAULT)\n" - "`uvm_field_int(cc, UVM_DEFAULT)\n" - "`uvm_object_utils_begin(bb)\n" - "`uvm_field_int(bb, UVM_DEFAULT)\n" - "`uvm_field_int(cc, UVM_DEFAULT)\n" - "`uvm_object_utils_end\n" - "`uvm_field_int(bb, UVM_DEFAULT)\n" - "`uvm_field_int(cc, UVM_DEFAULT)\n", - "`uvm_object_utils_begin(aa)\n" - " `uvm_field_int(bb, UVM_DEFAULT)\n" - " `uvm_field_int(cc, UVM_DEFAULT)\n" - "`uvm_object_utils_end\n" - "`uvm_field_int(bb, UVM_DEFAULT)\n" - "`uvm_field_int(cc, UVM_DEFAULT)\n" - "`uvm_object_utils_begin(bb)\n" - " `uvm_field_int(bb, UVM_DEFAULT)\n" - " `uvm_field_int(cc, UVM_DEFAULT)\n" - "`uvm_object_utils_end\n" - "`uvm_field_int(bb, UVM_DEFAULT)\n" - "`uvm_field_int(cc, UVM_DEFAULT)\n"}, - { - // empty uvm.*begin - uvm.*end range - "`uvm_component_utils_begin(aa)\n" - "`uvm_component_utils_end\n", - "`uvm_component_utils_begin(aa)\n" - "`uvm_component_utils_end\n", - }, - { - // uvm_field_utils - "`uvm_field_utils_begin(aa)\n" - "`uvm_field_int(bb, UVM_DEFAULT)\n" - "`uvm_field_int(cc, UVM_DEFAULT)\n" - "`uvm_field_utils_end\n", - "`uvm_field_utils_begin(aa)\n" - " `uvm_field_int(bb, UVM_DEFAULT)\n" - " `uvm_field_int(cc, UVM_DEFAULT)\n" - "`uvm_field_utils_end\n", - }, - { - // uvm_component - "`uvm_component_utils_begin(aa)\n" - "`uvm_field_int(bb, UVM_DEFAULT)\n" - "`uvm_field_int(cc, UVM_DEFAULT)\n" - "`uvm_component_utils_end\n", - "`uvm_component_utils_begin(aa)\n" - " `uvm_field_int(bb, UVM_DEFAULT)\n" - " `uvm_field_int(cc, UVM_DEFAULT)\n" - "`uvm_component_utils_end\n", - }, - { - // nested uvm macros - "`uvm_field_int(l0, UVM_DEFAULT)\n" - "`uvm_component_utils_begin(l0)\n" - "`uvm_field_int(l1, UVM_DEFAULT)\n" - "`uvm_component_utils_begin(l1)\n" - "`uvm_field_int(l2, UVM_DEFAULT)\n" - "`uvm_component_utils_begin(l2)\n" - "`uvm_field_int(l3, UVM_DEFAULT)\n" - "`uvm_component_utils_end\n" - "`uvm_field_int(l2, UVM_DEFAULT)\n" - "`uvm_component_utils_end\n" - "`uvm_field_int(l1, UVM_DEFAULT)\n" - "`uvm_component_utils_end\n" - "`uvm_field_int(l0, UVM_DEFAULT)\n", - "`uvm_field_int(l0, UVM_DEFAULT)\n" - "`uvm_component_utils_begin(l0)\n" - " `uvm_field_int(l1, UVM_DEFAULT)\n" - " `uvm_component_utils_begin(l1)\n" - " `uvm_field_int(l2, UVM_DEFAULT)\n" - " `uvm_component_utils_begin(l2)\n" - " `uvm_field_int(l3, UVM_DEFAULT)\n" - " `uvm_component_utils_end\n" - " `uvm_field_int(l2, UVM_DEFAULT)\n" - " `uvm_component_utils_end\n" - " `uvm_field_int(l1, UVM_DEFAULT)\n" - "`uvm_component_utils_end\n" - "`uvm_field_int(l0, UVM_DEFAULT)\n", - }, - { - // non-uvm macro - "`my_macro_begin(aa)\n" - "`my_field(b)\n" - "`my_field(c)\n" - "`my_macro_end\n", - "`my_macro_begin(aa)\n" - "`my_field(b)\n" - "`my_field(c)\n" - "`my_macro_end\n", - }, - { - // unbalanced uvm macros: missing uvm.*end macro - "`uvm_component_utils_begin(aa)\n" - "`uvm_field_int(bb, UVM_DEFAULT)\n" - "`uvm_field_int(cc, UVM_DEFAULT)\n", - "`uvm_component_utils_begin(aa)\n" - "`uvm_field_int(bb, UVM_DEFAULT)\n" - "`uvm_field_int(cc, UVM_DEFAULT)\n", - }, - { - // unbalanced uvm macros: missing uvm.*begin macro - "`uvm_field_int(bb, UVM_DEFAULT)\n" - "`uvm_field_int(cc, UVM_DEFAULT)\n" - "`uvm_component_utils_end\n", - "`uvm_field_int(bb, UVM_DEFAULT)\n" - "`uvm_field_int(cc, UVM_DEFAULT)\n" - "`uvm_component_utils_end\n", - }, - {// unbalanced uvm macros: missing _begin macro between - // matching uvm.*begin-uvm.*end macros - "`uvm_component_utils_begin(aa)\n" - "`uvm_field_int(bb, UVM_DEFAULT)\n" - "`uvm_field_int(cc, UVM_DEFAULT)\n" - "`uvm_component_utils_end\n" - "`uvm_field_int(bb, UVM_DEFAULT)\n" - "`uvm_field_int(bb, UVM_DEFAULT)\n" - "`uvm_field_int(cc, UVM_DEFAULT)\n" - "`uvm_component_utils_end\n" - "`uvm_field_int(bb, UVM_DEFAULT)\n" - "`uvm_component_utils_begin(aa)\n" - "`uvm_field_int(bb, UVM_DEFAULT)\n" - "`uvm_field_int(cc, UVM_DEFAULT)\n" - "`uvm_component_utils_end\n", - "`uvm_component_utils_begin(aa)\n" - " `uvm_field_int(bb, UVM_DEFAULT)\n" - " `uvm_field_int(cc, UVM_DEFAULT)\n" - "`uvm_component_utils_end\n" - "`uvm_field_int(bb, UVM_DEFAULT)\n" - "`uvm_field_int(bb, UVM_DEFAULT)\n" - "`uvm_field_int(cc, UVM_DEFAULT)\n" - "`uvm_component_utils_end\n" - "`uvm_field_int(bb, UVM_DEFAULT)\n" - "`uvm_component_utils_begin(aa)\n" - " `uvm_field_int(bb, UVM_DEFAULT)\n" - " `uvm_field_int(cc, UVM_DEFAULT)\n" - "`uvm_component_utils_end\n"}, - - // top-level directive test cases - {"`timescale 1ns/1ps\n", // - "`timescale 1ns / 1ps\n"}, - - // Multiple compiler directives should remain on separate lines - // (regression test for bug where they were merged onto one line) - {"`timescale 1 ps / 1 ps\n" - "`default_nettype none\n", - "`timescale 1 ps / 1 ps\n" - "`default_nettype none\n"}, - {"`resetall\n" - "`timescale 1ns/1ps\n" - "`default_nettype wire\n", - "`resetall\n" - "`timescale 1ns / 1ps\n" - "`default_nettype wire\n"}, - // Test with multiple different compiler directives - {"`resetall\n" - "`celldefine\n" - "`timescale 1ns/1ps\n" - "`default_nettype none\n", - "`resetall\n" - "`celldefine\n" - "`timescale 1ns / 1ps\n" - "`default_nettype none\n"}, - // Test with compiler directives before module - {"`timescale 1ps/1ps\n" - "`default_nettype none\n" - "module foo;endmodule\n", - "`timescale 1ps / 1ps\n" - "`default_nettype none\n" - "module foo;\nendmodule\n"}, - // Test with various compiler directives - {"`suppress_faults\n" - "`enable_portfaults\n" - "`delay_mode_distributed\n", - "`suppress_faults\n" - "`enable_portfaults\n" - "`delay_mode_distributed\n"}, - {"`default_decay_time 10\n" - "`default_trireg_strength 50\n", - "`default_decay_time 10\n" - "`default_trireg_strength 50\n"}, - // Alignment should ignore compiler directives; declarations align normally. - // Place directives at top-level between modules (valid SystemVerilog). - {"`timescale 1ns/1ps\n" - "module m;\n" - " logic a;\n" - " logic very_long_name;\n" - "endmodule\n" - "`default_nettype none\n" - "module n;\n" - " logic b;\n" - "endmodule\n", - "`timescale 1ns / 1ps\n" - "module m;\n" - " logic a;\n" - " logic very_long_name;\n" - "endmodule\n" - "`default_nettype none\n" - "module n;\n" - " logic b;\n" - "endmodule\n"}, - {"`begin_keywords \"1800-2017\"\n" - "module test;endmodule\n" - "`end_keywords\n", - "`begin_keywords \"1800-2017\"\n" - "module test;\nendmodule\n" - "`end_keywords\n"}, - - // parameter test cases - { - " parameter int foo=0 ;", - "parameter int foo = 0;\n", - }, - { - " parameter int foo=bar [ 0 ] ;", // index expression - "parameter int foo = bar[0];\n", - }, - { - " parameter int foo=bar [ a+b ] ;", // binary inside index expr - "parameter int foo = bar[a+b];\n", // allowed to be 0 spaces - // (preserved) - }, - { - " parameter int foo=bar [ a+ b ] ;", // binary inside index expr - "parameter int foo = bar[a+b];\n", // allowed to be 0 spaces - // (symmetrized) - }, - { - " parameter int foo=bar [ a +b ] ;", // compact binary inside - "parameter int foo = bar[a+b];\n", // index expression - }, - { - " parameter int foo=bar [ a +b ] ;", // compact binary inside - "parameter int foo = bar[a+b];\n", // index expression - }, - { - // with line continuations - " parameter \\\nint \\\nfoo=a+ \\\nb ;", - "parameter\\\n int\\\n foo = a +\\\n b;\n", - // TODO(fangism): should text following a line continuation hang-indent? - }, - // unary prefix expressions - { - " parameter int foo=- 1 ;", - "parameter int foo = -1;\n", - }, - { - " parameter int foo=+ 7 ;", - "parameter int foo = +7;\n", - }, - { - " parameter int foo=- J ;", - "parameter int foo = -J;\n", - }, - { - " parameter int foo=- ( y ) ;", - "parameter int foo = -(y);\n", - }, - { - " parameter int foo=- ( z*y ) ;", - "parameter int foo = -(z * y);\n", - }, - { - " parameter int foo=- z*- y ;", - "parameter int foo = -z * -y;\n", - }, - { - " parameter int foo=( - 2 ) ;", // - "parameter int foo = (-2);\n", - }, - { - " parameter int foo=$bar(- z,- y ) ;", - "parameter int foo = $bar(-z, -y);\n", - }, - {" parameter int a=b&~(c<<d);", "parameter int a = b & ~(c << d);\n"}, - {" parameter int a=~~~~b;", "parameter int a = ~~~~b;\n"}, - {" parameter int a = ~ ~ ~ ~ b;", "parameter int a = ~~~~b;\n"}, - {" parameter int a = ~--b;", "parameter int a = ~--b;\n"}, - {" parameter int a = ~ --b;", "parameter int a = ~--b;\n"}, - {" parameter int a = ~ ++ b;", "parameter int a = ~++b;\n"}, - {" parameter int a=--b- --c;", "parameter int a = --b - --c;\n"}, - // ^~ and ~^ are bitwise nor, but ^ ~ isn't - {" parameter int a=b^~(c<<d);", "parameter int a = b ^~ (c << d);\n"}, - {" parameter int a=b~^(c<<d);", "parameter int a = b ~^ (c << d);\n"}, - {" parameter int a=b^ ~ (c<<d);", "parameter int a = b ^ ~(c << d);\n"}, - {" parameter int a=b ^ ~(c<<d);", "parameter int a = b ^ ~(c << d);\n"}, - - {" parameter int a=b^~{c};", "parameter int a = b ^~ {c};\n"}, - {" parameter int a=b~^{c};", "parameter int a = b ~^ {c};\n"}, - {" parameter int a=b^ ~ {c};", "parameter int a = b ^ ~{c};\n"}, - {" parameter int a=b ^ ~{c};", "parameter int a = b ^ ~{c};\n"}, - - {" parameter int a={a}^{b};", "parameter int a = {a} ^ {b};\n"}, - {" parameter int a={b}^(c);", "parameter int a = {b} ^ (c);\n"}, - {" parameter int a=b[0]^ {c};", "parameter int a = b[0] ^ {c};\n"}, - {" parameter int a={c}^a[b];", "parameter int a = {c} ^ a[b];\n"}, - {" parameter int a=(c)^{a[b]};", "parameter int a = (c) ^ {a[b]};\n"}, - - {" parameter int a={^{a,^b},c};", "parameter int a = {^{a, ^b}, c};\n"}, - {" parameter int a=(a)^(^d[e]^{c});", - "parameter int a = (a) ^ (^d[e] ^ {c});\n"}, - {" parameter int a=(a)^(^d[e]^f[g]);", - "parameter int a = (a) ^ (^d[e] ^ f[g]);\n"}, - {" parameter int a=(b^(c^(d^e)));", - "parameter int a = (b ^ (c ^ (d ^ e)));\n"}, - {" parameter int a={b^{c^{d^e}}};", - "parameter int a = {b ^ {c ^ {d ^ e}}};\n"}, - {" parameter int a={b^{c[d^e]}};", - "parameter int a = {b ^ {c[d^e]}};\n"}, // allow 0 spaces inside "[d^e]" - {" parameter int a={(b^c),(d^^e)};", - "parameter int a = {(b ^ c), (d ^ ^e)};\n"}, - - {" parameter int a={(b[x]^{c[y]})};", - "parameter int a = {(b[x] ^ {c[y]})};\n"}, - {" parameter int a={d^^e[f] ^ (g)};", - "parameter int a = {d ^ ^e[f] ^ (g)};\n"}, - - // ~| is unary reduction NOR, |~ and | ~ aren't - {" parameter int a=b| ~(c<<d);", "parameter int a = b | ~(c << d);\n"}, - {" parameter int a=b|~(c<<d);", "parameter int a = b | ~(c << d);\n"}, - {" parameter int a=b| ~| ( c<<d);", "parameter int a = b | ~|(c << d);\n"}, - {" parameter int a=b| ~| ~| ( c<<d);", - "parameter int a = b | ~|~|(c << d);\n"}, - {" parameter int a=b| ~~~( c<<d);", - "parameter int a = b | ~~~(c << d);\n"}, - { - " parameter int foo=- - 1 ;", // double negative - "parameter int foo = - -1;\n", - }, - { - " parameter int ternary=1?2:3;", - "parameter int ternary = 1 ? 2 : 3;\n", - }, - { - " parameter int ternary=a?b:c;", - "parameter int ternary = a ? b : c;\n", - }, - { - " parameter int ternary=\"a\"?\"b\":\"c\";", - "parameter int ternary = \"a\" ? \"b\" : \"c\";\n", - }, - { - " parameter int t=`\"a`\"?`\"b`\":`\"c`\";", - "parameter int t = `\"a`\" ? `\"b`\" : `\"c`\";\n", - }, - { - " parameter int ternary=(a)?(b):(c);", - "parameter int ternary = (a) ? (b) : (c);\n", - }, - { - " parameter int ternary={a}?{b}:{c};", - "parameter int ternary = {a} ? {b} : {c};\n", - }, - { - " parameter int long_ternary=cond?long_option_t:long_option_f;", - "parameter int long_ternary = cond ?\n" - " long_option_t : long_option_f;\n", - }, - { - " parameter int break_two=cond\n" - "? a_really_long_option_number_one:a_really_long_option_number_two;", - "parameter int break_two = cond ?\n" - " a_really_long_option_number_one :\n" - " a_really_long_option_number_two;\n", - }, - { - " assign ternary=1?2:3;", - "assign ternary = 1 ? 2 : 3;\n", - }, - { - " assign ternary=a?b:c;", - "assign ternary = a ? b : c;\n", - }, - { - " assign ternary={a}?{b}:{c};", - "assign ternary = {a} ? {b} : {c};\n", - }, - { - " assign break_two=cond\n" - "? a_really_long_option_number_one:a_really_long_option_number_two;", - "assign break_two = cond ?\n" - " a_really_long_option_number_one :\n" - " a_really_long_option_number_two;\n", - }, - { - "assign prefetch_d =\n" - "lookup_grant_ic0 ? (lookup_addr_aligned + ADDR) :\n" - " addr_i;", - "assign prefetch_d = lookup_grant_ic0 ?\n" - " (lookup_addr_aligned + ADDR) :\n" - " addr_i;\n", - }, - { - "assign prefetch_d =\n" - "lookup_grant_ic0 ? (lookup_addr + 1) :\n" - " addr_i;", - "assign prefetch_d = lookup_grant_ic0 ?\n" - " (lookup_addr + 1) : addr_i;\n", - }, - { - "module test;\n" - " assign next = // EOL\n" - " foo ? '0 :\n" - " cnt;\n" - "endmodule\n", - "module test;\n" - " assign next = // EOL\n" - " foo ? '0 : cnt;\n" - "endmodule\n", - }, - { - "module test;\n" - " assign next = foo // EOL\n" - " ? '0 :\n" - " cnt;\n" - "endmodule\n", - "module test;\n" - " assign next = foo // EOL\n" - " ? '0 : cnt;\n" - "endmodule\n", - }, - { - "module test;\n" - " assign next = foo ? // EOL\n" - " '0 :\n" - " cnt;\n" - "endmodule\n", - "module test;\n" - " assign next = foo ? // EOL\n" - " '0 : cnt;\n" - "endmodule\n", - }, - { - "module test;\n" - " assign next = foo ? '0 // EOL\n" - " :\n" - " cnt;\n" - "endmodule\n", - "module test;\n" - " assign next = foo ? '0 // EOL\n" - " : cnt;\n" - "endmodule\n", - }, - { - "module test;\n" - " assign next = foo ? '0 : // EOL\n" - " cnt;\n" - "endmodule\n", - "module test;\n" - " assign next = foo ? '0 : // EOL\n" - " cnt;\n" - "endmodule\n", - }, - { - "module test;\n" - " assign next = foo ? '0 : // EOL\n" - " bar ? '1 : '0;\n" - "endmodule\n", - "module test;\n" - " assign next = foo ? '0 : // EOL\n" - " bar ? '1 : '0;\n" - "endmodule\n", - }, - { - "module test;\n" - " assign next = foo ? '0 : // EOL\n" - " bar // EOL2\n" - " ? '1 : '0;\n" - "endmodule\n", - "module test;\n" - " assign next = foo ? '0 : // EOL\n" - " bar // EOL2\n" - " ? '1 : '0;\n" - "endmodule\n", - }, - { - "module test;\n" - " assign next = foo ? '0 : // EOL\n" - " bar ? // EOL2\n" - " '1 : '0;\n" - "endmodule\n", - "module test;\n" - " assign next = foo ? '0 : // EOL\n" - " bar ? // EOL2\n" - " '1 : '0;\n" - "endmodule\n", - }, - { - "module test;\n" - " assign next = foo ? '0 : // EOL\n" - " bar ? '1 // EOL2\n" - " : '0;\n" - "endmodule\n", - "module test;\n" - " assign next = foo ? '0 : // EOL\n" - " bar ? '1 // EOL2\n" - " : '0;\n" - "endmodule\n", - }, - { - "module test;\n" - " assign next = foo ? '0 : // EOL\n" - " bar ? '1 : // EOL2\n" - " '0;\n" - "endmodule\n", - "module test;\n" - " assign next = foo ? '0 : // EOL\n" - " bar ? '1 : // EOL2\n" - " '0;\n" - "endmodule\n", - }, - { - "assign prefetch_d =\n" - "lookup_ic0 ? // EOL\n" - " (lookup_addr + 1) :// BOO\n" - " addr_i;", - "assign prefetch_d = lookup_ic0 ? // EOL\n" - " (lookup_addr + 1) : // BOO\n" - " addr_i;\n", - }, - { - "module test;\n" - " assign next = (foo) ? '0 : // clear \n" - " (bar) ? cnt + 1'b1 : // count \n" - " cnt;\n" - "endmodule\n", - "module test;\n" - " assign next = (foo) ? '0 : // clear \n" - " (bar) ? cnt + 1'b1 : // count \n" - " cnt;\n" - "endmodule\n", - }, - { - "module test;\n" - " assign next = // FOO\n" - " (foo) ? '0 : // clear \n" - " (bar) ? cnt + 1'b1 : // count \n" - " cnt;\n" - "endmodule\n", - "module test;\n" - " assign next = // FOO\n" - " (foo) ? '0 : // clear \n" - " (bar) ? cnt + 1'b1 : // count \n" - " cnt;\n" - "endmodule\n", - }, - { - "module test;\n" - " assign next = foo ? a_really_long_identifier : // EOL\n" - " cnt;\n" - "endmodule\n", - "module test;\n" - " assign next = foo ?\n" - " a_really_long_identifier : // EOL\n" - " cnt;\n" - "endmodule\n", - }, - { - "module test;\n" - " assign next = foo ? a_really_long_identifier : // EOL\n" - " another_really_long_identifier;\n" - "endmodule\n", - "module test;\n" - " assign next = foo ?\n" - " a_really_long_identifier : // EOL\n" - " another_really_long_identifier;\n" - "endmodule\n", - }, - { - "module test;\n" - " assign next = foo ? a_really_long_identifier : " - "another_really_long_identifier;\n" - "endmodule\n", - "module test;\n" - " assign next = foo ?\n" - " a_really_long_identifier :\n" - " another_really_long_identifier;\n" - "endmodule\n", - }, - { - "assign m = check ? {10'b0, foo} :\n" - " (bar && (baz == '0)) ? hello :\n" - " world ? temp1 : temp2;\n", - "assign m = check ? {10'b0, foo} :\n" - " (bar && (baz == '0)) ? hello :\n" - " world ? temp1 : temp2;\n", - }, - { - "assign {a, b} = !(c == d) ? {1'b0, e} :\n" - " ((e == f) && g) ?\n" - " {1'b0, f} : (h) ?\n" - " {1'b0, e} - 1'b1 :\n" - " {1'b0, e} + 1'b1;\n", - "assign {a, b} = !(c == d) ? {1'b0, e} :\n" - " ((e == f) && g) ? {1'b0, f} : (h) ?\n" - " {1'b0, e} - 1'b1 : {1'b0, e} + 1'b1;\n", - }, - { - "assign {aaaaaaaaaa, bbbbbbbbb} = {1'b0, cccccccccccccccccc[15:0]} +\n" - " {1'b0, ddddddddddddddddd[15:0]};\n", - "assign {aaaaaaaaaa, bbbbbbbbb} =\n" - " {1'b0, cccccccccccccccccc[15:0]} +\n" - " {1'b0, ddddddddddddddddd[15:0]};\n", - }, - { - "covergroup a(string b);\n" - "foobar: cross foo, bar {" - "ignore_bins baz = binsof(qux) intersect {1, 2, 3, 4, 5, 6, 7};" - "}\n" - "endgroup : a\n", - "covergroup a(string b);\n" - " foobar: cross foo, bar{\n" - " ignore_bins baz =\n" - " binsof (qux) intersect {\n" - " 1, 2, 3, 4, 5, 6, 7\n" - " };\n" - " }\n" - "endgroup : a\n", - }, - { - "assign {aa, bb} = {1'b0, cc} + {1'b0, dd};\n", - "assign {aa, bb} = {1'b0, cc} +\n" - " {1'b0, dd};\n", - }, - - // streaming operators - { - " parameter int b={ >> { a } } ;", - "parameter int b = {>>{a}};\n", - }, - { - " parameter int b={ >> { a , b, c } } ;", - "parameter int b = {>>{a, b, c}};\n", - }, - { - " parameter int b={ >> 4 { a } } ;", - "parameter int b = {>>4{a}};\n", - }, - { - " parameter int b={ >> byte { a } } ;", - "parameter int b = {>>byte{a}};\n", - }, - { - " parameter int b={ >> my_type_t { a } } ;", - "parameter int b = {>>my_type_t{a}};\n", - }, - { - " parameter int b={ >> `GET_TYPE { a } } ;", - "parameter int b = {>>`GET_TYPE{a}};\n", - }, - { - " parameter int b={ >> 4 {{ >> 2 { a } }} } ;", - "parameter int b = {>>4{{>>2{a}}}};\n", - }, - { - " parameter int b={ << { a } } ;", - "parameter int b = {<<{a}};\n", - }, - { - " parameter int b={ << { a , b, c } } ;", - "parameter int b = {<<{a, b, c}};\n", - }, - { - " parameter int b={ << 4 { a } } ;", - "parameter int b = {<<4{a}};\n", - }, - { - " parameter int b={ << byte { a } } ;", - "parameter int b = {<<byte{a}};\n", - }, - { - " parameter int b={ << my_type_t { a } } ;", - "parameter int b = {<<my_type_t{a}};\n", - }, - { - " parameter int b={ << `GET_TYPE { a } } ;", - "parameter int b = {<<`GET_TYPE{a}};\n", - }, - { - " parameter int b={ << 4 {{ << 2 { a } }} } ;", - "parameter int b = {<<4{{<<2{a}}}};\n", - }, - - // basic module test cases - {"module foo;endmodule:foo\n", - "module foo;\n" - "endmodule : foo\n"}, - {"module\nfoo\n;\nendmodule\n:\nfoo\n", - "module foo;\n" - "endmodule : foo\n"}, - {"module\tfoo\t;\tendmodule\t:\tfoo", - "module foo;\n" - "endmodule : foo\n"}, - {"module foo; // foo\n" - "endmodule:foo\n", - "module foo; // foo\n" - "endmodule : foo\n"}, - {"module foo;/* foo */endmodule:foo\n", - "module foo; /* foo */\n" - "endmodule : foo\n"}, - {"module pm #(\n" - "//comment\n" - ") (wire ww);\n" - "endmodule\n", - "module pm #(\n" - " //comment\n" // comment indented - ") (\n" - " wire ww\n" - ");\n" - "endmodule\n"}, - {"module pm ( ) ;\n" // empty ports list - "endmodule\n", - "module pm ();\n" - "endmodule\n"}, - {"module pm #(\n" - "//comment\n" - ") ( );\n" - "endmodule\n", - "module pm #(\n" - " //comment\n" // comment indented - ") ();\n" // (); grouped together - "endmodule\n"}, - {"`ifdef FOO\n" - " `ifndef BAR\n" - " `endif\n" - "`endif\n", - "`ifdef FOO\n" - "`ifndef BAR\n" - "`endif\n" - "`endif\n"}, - {"module foo(\n" - " `include \"ports.svh\"\n" - " ) ; endmodule\n", - "module foo (\n" - " `include \"ports.svh\"\n" - ");\n" - "endmodule\n"}, - {"module foo(\n" - " `define FOO\n" - "`undef\tFOO\n" - " ) ; endmodule\n", - "module foo (\n" - " `define FOO\n" - " `undef FOO\n" - ");\n" - "endmodule\n"}, - {"module foo( input x , output y ) ;endmodule:foo\n", - "module foo (\n" - " input x,\n" // aligned - " output y\n" - ");\n" - "endmodule : foo\n"}, - {"module foo(\n" - "// comment\n" - " input x , output y ) ;endmodule:foo\n", - "module foo (\n" - " // comment\n" - " input x,\n" // aligned - " output y\n" - ");\n" - "endmodule : foo\n"}, - {"module foo( input[2:0]x , output y [3:0] ) ;endmodule:foo\n", - // each port item should be on its own line - "module foo (\n" - " input [2:0] x,\n" // aligned - " output y[3:0]\n" - ");\n" - "endmodule : foo\n"}, - {"module foo( input wire x , output reg yy ) ;endmodule:foo\n", - "module foo (\n" - " input wire x,\n" // aligned - " output reg yy\n" - ");\n" - "endmodule : foo\n"}, - {"module foo( input wire x ,//c1\n" - "output reg yyy //c2\n" - " ) ;endmodule:foo\n", - "module foo (\n" - " input wire x, //c1\n" // aligned - " output reg yyy //c2\n" // aligned - ");\n" - "endmodule : foo\n"}, - {"module foo( input wire x ,/* c1 */\n" - "output reg yyy /* c2 */\n" - " ) ;endmodule:foo\n", - "module foo (\n" - " input wire x, /* c1 */\n" // aligned - " output reg yyy /* c2 */\n" // aligned - ");\n" - "endmodule : foo\n"}, - {"module foo(\n" - "// comment\n" - "input wire x ,//c1\n" - "output reg yyy //c2\n" - " ) ;endmodule:foo\n", - "module foo (\n" - " // comment\n" - " input wire x, //c1\n" // aligned - " output reg yyy //c2\n" // aligned - ");\n" - "endmodule : foo\n"}, - {"module foo(\n" - "/* comment */\n" - "input wire x ,/* c1 */\n" - "output reg yyy /* c2 */\n" - " ) ;endmodule:foo\n", - "module foo (\n" - " /* comment */\n" - " input wire x, /* c1 */\n" // aligned - " output reg yyy /* c2 */\n" // aligned - ");\n" - "endmodule : foo\n"}, - {"module foo( input wire x ,/* c1\n" - "c2\n" - "c3 */\n" - "output reg yyy /* c4 */\n" - " ) ;endmodule:foo\n", - "module foo (\n" - " input wire x, /* c1\n" - "c2\n" - "c3 */\n" // TODO: align multiline comments - " output reg yyy /* c4 */\n" - ");\n" - "endmodule : foo\n"}, - {"module foo( input wire x ,/* c1 */\n" - "output reg yyy,\n" - "output z // c2\n" - " ) ;endmodule:foo\n", - "module foo (\n" - " input wire x, /* c1 */\n" // aligned - " output reg yyy,\n" - " output z // c2\n" // aligned - ");\n" - "endmodule : foo\n"}, - {"module m(input logic [4:0] foo, // comment\n" - "input logic bar // comment\n" - " ) ;endmodule:m\n", - "module m (\n" - " input logic [4:0] foo, // comment\n" // aligned - " input logic bar // comment\n" // aligned - ");\n" - "endmodule : m\n"}, - {"module foo( input wire x , output yy ) ;endmodule:foo\n", - "module foo (\n" - " input wire x,\n" // aligned - " output yy\n" - ");\n" - "endmodule : foo\n"}, - {"module foo( input x , output reg yy ) ;endmodule:foo\n", - "module foo (\n" - " input x,\n" // aligned - " output reg yy\n" - ");\n" - "endmodule : foo\n"}, - {"module foo( input x , output reg[a:b]yy ) ;endmodule:foo\n", - "module foo (\n" - " input x,\n" // aligned - " output reg [a:b] yy\n" - ");\n" - "endmodule : foo\n"}, - {"module foo( input [a:b]x , output reg yy ) ;endmodule:foo\n", - "module foo (\n" - " input [a:b] x,\n" // aligned - " output reg yy\n" - ");\n" - "endmodule : foo\n"}, - {"module foo( input x , " - " output logic yy ) ;endmodule:foo\n", - "module foo (\n" - " input x,\n" // aligned - " output logic yy\n" - ");\n" - "endmodule : foo\n"}, - {"module foo( input [a:c]x , " - " output logic[a-b: c] yy ) ;endmodule:foo\n", - "module foo (\n" - " input [ a:c] x,\n" // aligned - " output logic [a-b:c] yy\n" - ");\n" - "endmodule : foo\n"}, - {"module foo( input [a:c]x , " - " output logic[a - b: c] yy ) ;endmodule:foo\n", - "module foo (\n" - " input [ a:c] x,\n" // aligned - " output logic [a - b:c] yy\n" - ");\n" - "endmodule : foo\n"}, - {"module foo( input [a:c]x , input zzz ," - " output logic[a - b: c] yy ) ;endmodule:foo\n", - "module foo (\n" - " input [ a:c] x,\n" // aligned []'s - " input zzz,\n" // aligned ids - " output logic [a - b:c] yy\n" - ");\n" - "endmodule : foo\n"}, - {"module foo( input [a:b]x , " - " output reg[e: f] yy ) ;endmodule:foo\n", - "module foo (\n" - " input [a:b] x,\n" // aligned - " output reg [e:f] yy\n" - ");\n" - "endmodule : foo\n"}, - {"module foo( input tri[aa: bb]x , " - " output reg[e: f] yy ) ;endmodule:foo\n", - "module foo (\n" - " input tri [aa:bb] x,\n" // aligned - " output reg [ e:f] yy\n" // TODO(b/70310743): align ':' - ");\n" - "endmodule : foo\n"}, - {"module foo( input [a:b][c:d]x , " - " output reg[e: f] yy ) ;endmodule:foo\n", - "module foo (\n" - " input [a:b][c:d] x,\n" // aligned - " output reg [e:f] yy\n" - ");\n" - "endmodule : foo\n"}, - {"module foo( input wire x [j:k], output reg yy ) ;endmodule:foo\n", - "module foo (\n" - " input wire x [j:k],\n" // aligned - " output reg yy\n" - ");\n" - "endmodule : foo\n"}, - {"module foo( input wire x , output reg yy [j:k]) ;endmodule:foo\n", - "module foo (\n" - " input wire x,\n" // aligned - " output reg yy[j:k]\n" - ");\n" - "endmodule : foo\n"}, - {"module foo( input wire x [p:q], output reg yy [j:k]) ;endmodule:foo\n", - "module foo (\n" - " input wire x [p:q],\n" // aligned - " output reg yy[j:k]\n" - ");\n" - "endmodule : foo\n"}, - {"module foo( input wire x [p:q][r:s], output reg yy [j:k]) " - ";endmodule:foo\n", - "module foo (\n" - " input wire x [p:q][r:s],\n" // aligned - " output reg yy[j:k]\n" - ");\n" - "endmodule : foo\n"}, - {"module foo( input wire x [p:q][rr:ss], output reg yy [jj:kk][m:n]) " - ";endmodule:foo\n", - "module foo (\n" - // TODO(b/70310743): align :'s - " input wire x [ p:q][rr:ss],\n" - " output reg yy[jj:kk][ m:n]\n" // aligned - ");\n" - "endmodule : foo\n"}, - {"module foo( input wire [p:q]x, output reg yy [j:k]) ;endmodule:foo\n", - "module foo (\n" - " input wire [p:q] x,\n" // aligned - " output reg yy[j:k]\n" - ");\n" - "endmodule : foo\n"}, - {"module foo( input wire x [p:q], output reg[j:k]yy) ;endmodule:foo\n", - "module foo (\n" - " input wire x [p:q],\n" // aligned - " output reg [j:k] yy\n" - ");\n" - "endmodule : foo\n"}, - {"module foo( input pkg::bar_t x , output reg yy) ;endmodule:foo\n", - "module foo (\n" - " input pkg::bar_t x,\n" // aligned - " output reg yy\n" - ");\n" - "endmodule : foo\n"}, - {"module foo( input wire x , output pkg::bar_t yy) ;endmodule:foo\n", - "module foo (\n" - " input wire x,\n" // aligned - " output pkg::bar_t yy\n" - ");\n" - "endmodule : foo\n"}, - {"module foo( input pkg::bar_t#(1) x , output reg yy) ;endmodule:foo\n", - "module foo (\n" // with parameterized port type - " input pkg::bar_t#(1) x,\n" - " output reg yy\n" // aligned - ");\n" - "endmodule : foo\n"}, - {"module foo( input signed x , output reg yy) ;endmodule:foo\n", - "module foo (\n" - " input signed x,\n" // aligned - " output reg yy\n" - ");\n" - "endmodule : foo\n"}, - {"module foo( input signed x , output reg [m:n] yy) ;endmodule:foo\n", - "module foo (\n" - " input signed x,\n" // aligned - " output reg [m:n] yy\n" - ");\n" - "endmodule : foo\n"}, - {"module foo( input int signed x , output reg [m:n] yy) ;endmodule:foo\n", - "module foo (\n" - " input int signed x,\n" // aligned - " output reg [m:n] yy\n" - ");\n" - "endmodule : foo\n"}, - {"module foo( input signed x , output pkg::bar_t yy) ;endmodule:foo\n", - "module foo (\n" - " input signed x,\n" // aligned - " output pkg::bar_t yy\n" - ");\n" - "endmodule : foo\n"}, - {"module somefunction (" - "logic clk, int a, int b);endmodule", - "module somefunction (\n" - " logic clk,\n" // direction missing - " int a,\n" // direction missing - " int b\n" // direction missing - ");\n" - "endmodule\n"}, - {"module somefunction (" - "logic clk, input int a, int b);endmodule", - "module somefunction (\n" - " logic clk,\n" // direction missing - " input int a,\n" - " int b\n" // direction missing - ");\n" - "endmodule\n"}, - {"module somefunction (" - "input logic clk, input int a, int b);endmodule", - "module somefunction (\n" - " input logic clk,\n" - " input int a,\n" - " int b\n" // direction missing - ");\n" - "endmodule\n"}, - {"module somefunction (" - "input clk, input int a, int b);endmodule", - "module somefunction (\n" - " input clk,\n" // type missing - " input int a,\n" - " int b\n" - ");\n" - "endmodule\n"}, - {"module somefunction (" - "input logic clk, input a, int b);endmodule", - "module somefunction (\n" - " input logic clk,\n" - " input a,\n" // type missing - " int b\n" // direction missing - ");\n" - "endmodule\n"}, - {"module t;\n" - " input bit i_bit;\n" - "input byte i_byte ;\n" - "input chandle i_chandle;\n" - "input event i_event;\n" - "input int i_int;\n" - "input integer i_inte;\n" - "input longint i_longint;\n" - "input real i_real;\n" - "input realtime i_realtime;\n" - "input shortint i_shortint;\n" - "input shortreal i_shortreal;\n" - "input string i_string;\n" - "input time i_time;\n" - " output bit o_bit;\n" - "output byte o_byte ; \n" - "output chandle o_chandle;\n" - "output event o_event;\n" - "output int o_int;\n" - "output integer o_inte;\n" - "output longint o_longint;\n" - "output real o_real;\n" - "output realtime o_realtime;\n" - "output shortint o_shortint;\n" - "output shortreal o_shortreal;\n" - "output string o_string;\n" - "output time o_time;\n" - "endmodule\n", - "module t;\n" - " input bit i_bit;\n" - " input byte i_byte;\n" - " input chandle i_chandle;\n" - " input event i_event;\n" - " input int i_int;\n" - " input integer i_inte;\n" - " input longint i_longint;\n" - " input real i_real;\n" - " input realtime i_realtime;\n" - " input shortint i_shortint;\n" - " input shortreal i_shortreal;\n" - " input string i_string;\n" - " input time i_time;\n" - " output bit o_bit;\n" - " output byte o_byte;\n" - " output chandle o_chandle;\n" - " output event o_event;\n" - " output int o_int;\n" - " output integer o_inte;\n" - " output longint o_longint;\n" - " output real o_real;\n" - " output realtime o_realtime;\n" - " output shortint o_shortint;\n" - " output shortreal o_shortreal;\n" - " output string o_string;\n" - " output time o_time;\n" - "endmodule\n"}, - {"module t (\n" - " input bit i_bit,\n" - "input byte i_byte ,\n" - "input chandle i_chandle,\n" - "input event i_event,\n" - "input int i_int,\n" - "input integer i_inte,\n" - "input longint i_longint,\n" - "input real i_real,\n" - "input realtime i_realtime,\n" - "input shortint i_shortint,\n" - "input shortreal i_shortreal,\n" - "input string i_string,\n" - "input time i_time,\n" - " output bit o_bit,\n" - "output byte o_byte , \n" - "output chandle o_chandle,\n" - "output event o_event,\n" - "output int o_int,\n" - "output integer o_inte,\n" - "output longint o_longint,\n" - "output real o_real,\n" - "output realtime o_realtime,\n" - "output shortint o_shortint,\n" - "output shortreal o_shortreal,\n" - "output string o_string,\n" - "output time o_time);\n" - "endmodule\n", - "module t (\n" - " input bit i_bit,\n" - " input byte i_byte,\n" - " input chandle i_chandle,\n" - " input event i_event,\n" - " input int i_int,\n" - " input integer i_inte,\n" - " input longint i_longint,\n" - " input real i_real,\n" - " input realtime i_realtime,\n" - " input shortint i_shortint,\n" - " input shortreal i_shortreal,\n" - " input string i_string,\n" - " input time i_time,\n" - " output bit o_bit,\n" - " output byte o_byte,\n" - " output chandle o_chandle,\n" - " output event o_event,\n" - " output int o_int,\n" - " output integer o_inte,\n" - " output longint o_longint,\n" - " output real o_real,\n" - " output realtime o_realtime,\n" - " output shortint o_shortint,\n" - " output shortreal o_shortreal,\n" - " output string o_string,\n" - " output time o_time\n" - ");\n" - "endmodule\n"}, - {"module m;foo bar(.baz({larry, moe, curly}));endmodule", - "module m;\n" - " foo bar (.baz({larry, moe, curly}));\n" - "endmodule\n"}, - {"module m;foo bar(.baz({larry,// expand this\n" - "moe, curly}));endmodule", - "module m;\n" - " foo bar (\n" - " .baz({\n" - " larry, // expand this\n" - " moe,\n" - " curly\n" - " })\n" - " );\n" - "endmodule\n"}, - {"parameter priv_reg_t impl_csr[] = {\n" - "// Machine mode mode CSR\n" - "MVENDORID, //\n" - "MARCHID, //\n" - "DSCRATCH0, //\n" - "DSCRATCH1 //\n" - "};", - "parameter priv_reg_t impl_csr[] = {\n" - " // Machine mode mode CSR\n" - " MVENDORID, //\n" - " MARCHID, //\n" - " DSCRATCH0, //\n" - " DSCRATCH1 //\n" - "};\n"}, - {"parameter priv_reg_t impl_csr[] = {\n" - "// Expand elements\n" - "MVENDORID,\n" - "MARCHID,\n" - "DSCRATCH0,\n" - "DSCRATCH1\n" - "};", - "parameter priv_reg_t impl_csr[] = {\n" - " // Expand elements\n" - " MVENDORID,\n" - " MARCHID,\n" - " DSCRATCH0,\n" - " DSCRATCH1\n" - "};\n"}, - /* TODO(b/158131099): to fix these, reinterpret 'b' as a kPortDeclaration - {"module somefunction (" - "input logic clk, input a, b);endmodule", - "module somefunction (\n" - " input logic clk,\n" - " input a,\n" // type missing - " b\n" // type and direction missing - ");\n" - "endmodule\n"}, - {"module somefunction (" - "input logic clk, int a, b);endmodule", - "module somefunction (\n" - " input logic clk,\n" - " int a,\n" // direction missing - " b\n" // type and direction missing - ");\n" - "endmodule\n"}, - */ - {"module foo(\n" - "//c1\n" - "input wire x , \n" - "//c2\n" - "output reg yy\n" - "//c3\n" - ") ;endmodule:foo\n", - "module foo (\n" - " //c1\n" - " input wire x,\n" // aligned, ignoring comments - " //c2\n" - " output reg yy\n" - " //c3\n" - ");\n" - "endmodule : foo\n"}, - {"module foo(\n" - "//c1\n" - "input wire x , \n" - "//c2a\n" // longer comment - "//c2b\n" - "output reg yy\n" - "//c3\n" - ") ;endmodule:foo\n", - "module foo (\n" - " //c1\n" - " input wire x,\n" // aligned, ignoring comments - " //c2a\n" // note: separated by 2 lines of comments - " //c2b\n" - " output reg yy\n" - " //c3\n" - ");\n" - "endmodule : foo\n"}, - {"module foo(\n" - "`ifdef FOO\n" - "input wire x , \n" - " `else\n" - "output reg yy\n" - " `endif\n" - ") ;endmodule:foo\n", - "module foo (\n" - "`ifdef FOO\n" - " input wire x,\n" // aligned, ignoring preprocessor conditionals - "`else\n" - " output reg yy\n" - "`endif\n" - ");\n" - "endmodule : foo\n"}, - {"module foo(\n" - "input w , \n" - "`define FOO BAR\n" - "input wire x , \n" - " `include \"stuff.svh\"\n" - "output reg yy\n" - " `undef FOO\n" - "output zz\n" - ") ;endmodule:foo\n", - "module foo (\n" - " input w,\n" // aligned, ignoring preprocessor directives - " `define FOO BAR\n" - " input wire x,\n" - " `include \"stuff.svh\"\n" - " output reg yy\n" - " `undef FOO\n" - " output zz\n" // aligned, ignoring preprocessor directives - ");\n" - "endmodule : foo\n"}, - {"module foo(\n" - "input wire x , \n \n" // blank line, separating alignment groups - "output reg yy\n" - ") ;endmodule:foo\n", - "module foo (\n" - " input wire x,\n" // not aligned, due to blank line separating groups - "\n" - " output reg yy\n" - ");\n" - "endmodule : foo\n"}, - {"module foo(\n" - "input wire x1 [r:s],\n" - "input [p:q] x2 , \n \n" // blank line, separating alignment groups - "output reg [jj:kk]yy1,\n" - "output pkg::barr_t [mm:nn] yy2\n" - ") ;endmodule:foo\n", - "module foo (\n" - " input wire x1[r:s],\n" // aligned in this group, but not across - // groups - " input [p:q] x2,\n" - "\n" - " output reg [jj:kk] yy1,\n" - " output pkg::barr_t [mm:nn] yy2\n" - ");\n" - "endmodule : foo\n"}, - {"module foo(\n" // same as previous, with comments - " //c1\n" - "input wire x1 [r:s],\n" - "input [p:q] x2 , \n" - " //c2\n\n" // blank line, separating alignment groups - " //c3\n" - "output reg [jj:kk]yy1,\n" - " //c4\n" - "output pkg::barr_t [mm:nn] yy2\n" - ") ;endmodule:foo\n", - "module foo (\n" - " //c1\n" - " input wire x1[r:s],\n" // aligned in this group, but not across - // groups - " input [p:q] x2,\n" - " //c2\n" - "\n" - " //c3\n" - " output reg [jj:kk] yy1,\n" - " //c4\n" - " output pkg::barr_t [mm:nn] yy2\n" - ");\n" - "endmodule : foo\n"}, - - {// align null-statement (issue #824) - "class sample;" - "bit a;;" - "bit b;" - "endclass", - "class sample;\n" - " bit a;\n" - " ;\n" - " bit b;\n" - "endclass\n"}, - {"class sample;" - "bit a;;" - "endclass", - "class sample;\n" - " bit a;\n" - " ;\n" - "endclass\n"}, - {"class sample;" - "bit a;" - "bit b;;" - "endclass", - "class sample;\n" - " bit a;\n" - " bit b;\n" - " ;\n" - "endclass\n"}, - - {// aligning here just barely fits in the 40col limit - "module foo( input int signed x [a:b]," - "output reg [mm:nn] yy) ;endmodule:foo\n", - "module foo (\n" - // ---------------40col-----------------> - " input int signed x [a:b],\n" // aligned, still fits - " output reg [mm:nn] yy\n" - ");\n" - "endmodule : foo\n"}, - {// when aligning would result in exceeding column limit, don't align for - // now - "module foo( input int signed x [aa:bb]," - "output reg [mm:nn] yy) ;endmodule:foo\n", - "module foo (\n" - // ---------------40col-----------------> - // input int signed x [aa:bb],\n" - // output reg [mm:nn] yy\n" - " input int signed x [aa:bb],\n" // aligned, still fits - " output reg [mm:nn] yy\n" - ");\n" - "endmodule : foo\n"}, - {// when aligning would result in exceeding column limit, don't align for - // now - "module foo( input int signed x [aa:bb]," - "output reg [mm:nn] yyy) ;endmodule:foo\n", - "module foo (\n" - // ---------------40col-----------------> - // input int signed x [aa:bb],\n" // over limit, by comma - // output reg [mm:nn] yyy\n" - " input int signed x[aa:bb],\n" // aligned would be 41 columns - " output reg [mm:nn] yyy\n" - ");\n" - "endmodule : foo\n"}, - {// when aligning would result in exceeding column limit, don't align for - // now - "module foo( input int signed x [a:b],//c\n" - "output reg [m:n] yy) ;endmodule:foo\n", - "module foo (\n" - // ---------------40col----------------> - // input int signed x [a:b], //c\n" // over limit, by comment - // output reg [m:n] yy\n" - " input int signed x[a:b], //c\n" // aligned would be 42 columns - " output reg [m:n] yy\n" - ");\n" - "endmodule : foo\n"}, - {// aligning interfaces in port headers like types - // TODO(b/161181877): flush interface port type left (multi-column) - "module foo( input clk , inter.face yy) ;endmodule:foo\n", - "module foo (\n" - " input clk,\n" // aligned - " inter.face yy\n" - ");\n" - "endmodule : foo\n"}, - {// aligning interfaces in port headers like types - // TODO(b/161181877): flush interface port type left (multi-column) - "module foo( input wire clk , inter.face yy) ;endmodule:foo\n", - "module foo (\n" - " input wire clk,\n" // aligned - " inter.face yy\n" - ");\n" - "endmodule : foo\n"}, - - // module local variable/net declaration alignment test cases - {"module m;\n" - "logic a;\n" - "bit b;\n" - "endmodule\n", - "module m;\n" - " logic a;\n" - " bit b;\n" - "endmodule\n"}, - {"module m;\n" - "logic a;\n" - "bit b;\n" - "initial e=f;\n" // separates alignment groups - "wire c;\n" - "bit d;\n" - "endmodule\n", - "module m;\n" - " logic a;\n" - " bit b;\n" - " initial e = f;\n" // separates alignment groups - " wire c;\n" - " bit d;\n" - "endmodule\n"}, - {"module m;\n" - "// hello a\n" - "logic a;\n" - "// hello b\n" - "bit b;\n" - "endmodule\n", - "module m;\n" - " // hello a\n" - " logic a;\n" - " // hello b\n" - " bit b;\n" // aligned across comments - "endmodule\n"}, - {"module m;\n" - "// hello a\n" - "logic a;\n" - "\n" // extra blank line - "// hello b\n" - "bit b;\n" - "endmodule\n", - "module m;\n" - " // hello a\n" - " logic a;\n" - "\n" // extra blank line - " // hello b\n" // aligned across blank lines - " bit b;\n" // aligned across comments - "endmodule\n"}, - {"module m;\n" - "logic [x:y]a;\n" // packed dimensions - "bit b;\n" - "endmodule\n", - "module m;\n" - " logic [x:y] a;\n" - " bit b;\n" - "endmodule\n"}, - {"module m;\n" - "logic a;\n" - "bit [pp:qq]b;\n" // packed dimensions - "endmodule\n", - "module m;\n" - " logic a;\n" - " bit [pp:qq] b;\n" - "endmodule\n"}, - {"module m;\n" - "logic [x:y]a;\n" // packed dimensions - "bit [pp:qq]b;\n" // packed dimensions - "endmodule\n", - "module m;\n" - " logic [ x:y] a;\n" - " bit [pp:qq] b;\n" - "endmodule\n"}, - {"module m;\n" - "logic [x:y]a;\n" // packed dimensions - "wire [pp:qq] [e:f]b;\n" // packed dimensions, 2D - "endmodule\n", - "module m;\n" - " logic [ x:y] a;\n" - " wire [pp:qq][e:f] b;\n" - "endmodule\n"}, - {"module m;\n" - "logic a [x:y];\n" // unpacked dimensions - "bit bbb;\n" - "endmodule\n", - "module m;\n" - " logic a [x:y];\n" - " bit bbb;\n" - "endmodule\n"}, - {"module m;\n" - "logic aaa ;\n" - "wire w [yy:zz];\n" // unpacked dimensions - "endmodule\n", - "module m;\n" - " logic aaa;\n" - " wire w [yy:zz];\n" - "endmodule\n"}, - {"module m;\n" - "logic aaa [s:t] ;\n" // unpacked dimensions - "wire w [yy:zz];\n" // unpacked dimensions - "endmodule\n", - "module m;\n" - " logic aaa[ s:t];\n" - " wire w [yy:zz];\n" - "endmodule\n"}, - {"module m;\n" - "logic aaa [s:t] ;\n" // unpacked dimensions - "wire w [yy:zz][u:v];\n" // unpacked dimensions, 2D - "endmodule\n", - "module m;\n" - " logic aaa[ s:t];\n" - " wire w [yy:zz] [u:v];\n" - // TODO(b/165323560): unwanted space between unpacked dimensions of 'w' - "endmodule\n"}, - {"module m;\n" - "qqq::rrr s;\n" // user-defined type - "wire [pp:qq]w;\n" // packed dimensions - "endmodule\n", - "module m;\n" - " qqq::rrr s;\n" - " wire [pp:qq] w;\n" - "endmodule\n"}, - {"module m;\n" - "qqq#(rr) s;\n" // parameterized type - "wire [pp:qq]w;\n" // packed dimensions - "endmodule\n", - "module m;\n" - " qqq #(rr) s;\n" - " wire [pp:qq] w;\n" - "endmodule\n"}, - {"module m;\n" - "logic a;\n" - "bit b;\n" - "my_module my_inst( );\n" // module instance separates alignment groups - "wire c;\n" - "bit d;\n" - "endmodule\n", - "module m;\n" - " logic a;\n" // these two are aligned - " bit b;\n" - " my_module my_inst ();\n" // module instance separates alignment groups - " wire c;\n" // these two are aligned - " bit d;\n" - "endmodule\n"}, - {"module m;\n" - "logic aaa = expr1;\n" - "bit b = expr2;\n" - "endmodule\n", - "module m;\n" - " logic aaa = expr1;\n" - " bit b = expr2;\n" // no alignment at '=' yet - "endmodule\n"}, - {"(* foo='{\"bar_.*\"} *)\n" // funny attribute - "module mattr;\n" - "(* attr1=\"value1\" *)\n" // attribute ignored - "ex_input_pins_t ex_input_pins;\n" - "(* attr2=\"value2\" *)\n" // attribute ignored - "ex_output_pins_t ex_output_pins;\n" - "(* attr3=\"value3\" *)\n" // attribute ignored - "ex wrap_ex ( );\n" - "endmodule\n", - "(* foo='{\"bar_.*\"} *)\n" - "module mattr;\n" - " (* attr1=\"value1\" *)\n" // indented - " ex_input_pins_t ex_input_pins;\n" // aligned - " (* attr2=\"value2\" *)\n" // indented - " ex_output_pins_t ex_output_pins;\n" - " (* attr3=\"value3\" *)\n" // indented - " ex wrap_ex ();\n" - "endmodule\n"}, - {"module mattr;\n" - "ex_input_pins_t ex_input_pins;\n" - "ex_output_pins_t ex_output_pins;\n" - "(* package_definition=\"ex_pkg\" *)\n" // attribute ignored - "ex wrap_ex (\n" - ".clk(ex_input_pins.clk),\n" - ".rst(ex_input_pins.rst),\n" - ".in(ex_input_pins.in)\n" - ");\n" - "endmodule\n", - "module mattr;\n" - " ex_input_pins_t ex_input_pins;\n" // aligned - " ex_output_pins_t ex_output_pins;\n" - " (* package_definition=\"ex_pkg\" *)\n" // indented - " ex wrap_ex (\n" - " .clk(ex_input_pins.clk),\n" - " .rst(ex_input_pins.rst),\n" - " .in (ex_input_pins.in)\n" // aligned - " );\n" - "endmodule\n"}, - {"module test;\n" - "bind entropy_src tlul_assert #(.EndpointType(\"Device\"))\n" - "tlul_assert_device (.clk_i, .rst_ni, .h2d(tl_i), .d2h(tl_o));\n" - "endmodule\n", - "module test;\n" - " bind entropy_src tlul_assert #(\n" - " .EndpointType(\"Device\")\n" - " ) tlul_assert_device (\n" - " .clk_i,\n" - " .rst_ni,\n" - " .h2d(tl_i),\n" - " .d2h(tl_o)\n" - " );\n" - "endmodule\n"}, - {"module test;\n" - "bind entropy_src tlul_assert #(.EndpointType(\"Device\"))\n" - "tlul_assert_device (.clk_i, .rst_ni,\n\n .h2d(tl_i),\n\n .d2h(tl_o));\n" - "endmodule\n", - "module test;\n" - " bind entropy_src tlul_assert #(\n" - " .EndpointType(\"Device\")\n" - " ) tlul_assert_device (\n" - " .clk_i,\n" - " .rst_ni,\n" - "\n" - " .h2d(tl_i),\n" - "\n" - " .d2h(tl_o)\n" - " );\n" - "endmodule\n"}, - {"bind expand_me long_name #(.W(W_CONST), .D(D_CONST)) instaaance_name (" - ".in(iiiiiiiin),\n\n .out(ooooooout),\n .clk(ccccccclk),\n\n" - ".in1234 (in),\n //c1\n .out1234(out),\n .clk1234(clk),);", - "bind expand_me long_name #(\n" - " .W(W_CONST),\n" - " .D(D_CONST)\n" - ") instaaance_name (\n" - " .in(iiiiiiiin),\n" - "\n" - " .out(ooooooout),\n" - " .clk(ccccccclk),\n" - "\n" - " .in1234 (in),\n" - " //c1\n" - " .out1234(out),\n" - " .clk1234(clk),\n" - ");\n"}, - {"initial // clock generation\n begin\n clk = 0;\n forever begin\n" - "#4ns clk = !clk;\n end\n end\n", - "initial // clock generation\n" - " begin\n" - " clk = 0;\n" - " forever begin\n" - " #4ns clk = !clk;\n" - " end\n" - " end\n"}, - {"module foo #(int x,int y) ;endmodule:foo\n", // parameters - "module foo #(\n" - " int x,\n" - " int y\n" - ");\n" // each parameter on its own line - "endmodule : foo\n"}, - {"module foo #(int x)(input y) ;endmodule:foo\n", - // parameter and port - "module foo #(\n" - " int x\n" - ") (\n" - " input y\n" - ");\n" // each paramater and port item should be on its own line - "endmodule : foo\n"}, - {"module foo #(parameter int x,parameter int y) ;endmodule:foo\n", - // parameters don't fit (also should be on its own line) - "module foo #(\n" - " parameter int x,\n" - " parameter int y\n" - ");\n" - "endmodule : foo\n"}, - {"module foo #(parameter int xxxx,parameter int yyyy) ;endmodule:foo\n", - // parameters don't fit - "module foo #(\n" - " parameter int xxxx,\n" - " parameter int yyyy\n" - ");\n" - "endmodule : foo\n"}, - {"module foo #(parameter int x = $clog2 (N) ,parameter int y ) " - ";endmodule:foo\n", - // parameters don't fit - "module foo #(\n" - " parameter int x = $clog2(N),\n" // no space after $clog2 - " parameter int y\n" - ");\n" - "endmodule : foo\n"}, - {"module foo #(//comment\n" - "parameter bar =1,\n" - "localparam baz =2" - ") ();" - "endmodule", - "module foo #( //comment\n" - " parameter bar = 1,\n" - " localparam baz = 2\n" - ") ();\n" - "endmodule\n"}, - {"module foo #(" - "parameter bar =1,//comment\n" - "localparam baz =2" - ") ();" - "endmodule", - "module foo #(\n" - " parameter bar = 1, //comment\n" - " localparam baz = 2\n" - ") ();\n" - "endmodule\n"}, - {"module foo #(" - "parameter bar =1," - "localparam baz =2//comment\n" - ") ();" - "endmodule", - "module foo #(\n" - " parameter bar = 1,\n" - " localparam baz = 2 //comment\n" - ") ();\n" - "endmodule\n"}, - {"module foo #(" - "parameter bar =1//comment\n" - ",localparam baz =2\n" - ") ();" - "endmodule", - "module foo #(\n" - " parameter bar = 1 //comment\n" - " , localparam baz = 2\n" - ") ();\n" - "endmodule\n"}, - {"module foo;" - // fit in one line - "parameter int i = '{\n" - "1,\n" - "2,\n" - "3\n" - "};\n" - "endmodule", - "module foo;\n" - " parameter int i = '{1, 2, 3};\n" - "endmodule\n"}, - {"module foo;" - // too long for one line, expand - "localparam logic [63:0] RC[24] = '{\n" - "64'h 1,\n" - "64'h 2,\n" - "64'h 3\n" - "};\n" - "endmodule", - "module foo;\n" - " localparam logic [63:0] RC[24] = '{\n" - " 64'h1,\n" - " 64'h2,\n" - " 64'h3\n" - " };\n" - "endmodule\n"}, - {"module foo;" - "parameter int i = '{\n" - // force expansion - "1, //\n" - "2,\n" - "3\n" - "};\n" - "endmodule", - "module foo;\n" - " parameter int i = '{\n" - " 1, //\n" - " 2,\n" - " 3\n" - " };\n" - "endmodule\n"}, - {"module foo;" - "localparam logic [63:0] RC[24] = '{\n" - "64'h 0000_0000_0000_0001, // 0\n" - "64'h 0000_0000_0000_8082, // 1\n" - "64'h 8000_0000_8000_8008 // 23\n" - "};\n" - "endmodule", - "module foo;\n" - " localparam logic [63:0] RC[24] = '{\n" - " 64'h0000_0000_0000_0001, // 0\n" - " 64'h0000_0000_0000_8082, // 1\n" - " 64'h8000_0000_8000_8008 // 23\n" - " };\n" - "endmodule\n"}, - {"module foo;" - // nest two patterns - "parameter logic [11:0] i = '{\n" - "'{1,2,3},\n" - "'{1,2,3}\n" - "};\n" - "endmodule", - "module foo;\n" - " parameter logic [11:0] i = '{\n" - " '{1, 2, 3},\n" - " '{1, 2, 3}\n" - " };\n" - "endmodule\n"}, - {"module foo;" - // nest two patterns, expand interior - "parameter logic [11:0] i = '{\n" - "'{1, //\n" - " 2,3},\n" - "'{1,2,3}\n" - "};\n" - "endmodule", - "module foo;\n" - " parameter logic [11:0] i = '{\n" - " '{\n" - " 1, //\n" - " 2,\n" - " 3\n" - " },\n" - " '{1, 2, 3}\n" - " };\n" - "endmodule\n"}, - {"module foo;" - // nest two patterns, expand both - "parameter nest [2] i = '{\n" - "'{first : 32'h0000_0001,\n" - " second : 32'h0000_0011,\n" - " third: 32'h0000_0111},\n" - "'{first : 32'h1000_0001,\n" - " second : 32'h1000_0011,\n" - " third: 32'h1000_0111}\n" - "};\n" - "endmodule", - "module foo;\n" - " parameter nest [2] i = '{\n" - " '{\n" - " first : 32'h0000_0001,\n" - " second : 32'h0000_0011,\n" - " third: 32'h0000_0111\n" - " },\n" - " '{\n" - " first : 32'h1000_0001,\n" - " second : 32'h1000_0011,\n" - " third: 32'h1000_0111\n" - " }\n" - " };\n" - "endmodule\n"}, - {"module foo;" - // nest three patterns - "parameter logic [11:0] i = '{\n" - "'{'{1,2,3},4}\n" - "};\n" - "endmodule", - "module foo;\n" - " parameter logic [11:0] i = '{\n" - " '{'{1, 2, 3}, 4}\n" - " };\n" - "endmodule\n"}, - {"module foo;" - // nest three patterns, expand interior - "parameter logic [11:0] i = '{\n" - "'{\n" - "'{first : 32'h0000_0001,\n" - " second : 32'h0000_0011,\n" - " third: 32'h0000_0111},\n" - " 4},\n" - " 5,\n" - " '{1,2,3}\n" - "};\n" - "endmodule", - "module foo;\n" - " parameter logic [11:0] i = '{\n" - " '{\n" - " '{\n" - " first : 32'h0000_0001,\n" - " second : 32'h0000_0011,\n" - " third: 32'h0000_0111\n" - " },\n" - " 4\n" - " },\n" - " 5,\n" - " '{1, 2, 3}\n" - " };\n" - "endmodule\n"}, - {"module top;" - "foo#( \"test\" ) foo( );" - "bar#( \"test\" ,5) bar( );" - "endmodule\n", - "module top;\n" - " foo #(\"test\") foo ();\n" // module instantiation, string arg - " bar #(\"test\", 5) bar ();\n" - "endmodule\n"}, - {"module top;" - "foo#( `\"test`\" ) foo( );" - "bar#( `\"test`\" ,5) bar( );" - "endmodule\n", - "module top;\n" - " foo #(`\"test`\") foo ();\n" // module instantiation, eval string arg - " bar #(`\"test`\", 5) bar ();\n" - "endmodule\n"}, - {"`ifdef FOO\n" - " module bar;endmodule\n" - "`endif\n", - "`ifdef FOO\n" - "module bar;\n" - "endmodule\n" - "`endif\n"}, - {"`ifdef FOO\n" - " module bar;endmodule\n" - "`else module baz;endmodule\n" - "`endif\n", - "`ifdef FOO\n" - "module bar;\n" - "endmodule\n" - "`else\n" - "module baz;\n" - "endmodule\n" - "`endif\n"}, - {"`ifdef FOO\n" - " module bar;endmodule\n" - "`else /* glue me */ module baz;endmodule\n" - "`endif\n", - "`ifdef FOO\n" - "module bar;\n" - "endmodule\n" - "`else /* glue me */\n" - "module baz;\n" - "endmodule\n" - "`endif\n"}, - {"`ifdef FOO\n" - " module bar;endmodule\n" - "`else// different unit\n" - " module baz;endmodule\n" - "`endif\n", - "`ifdef FOO\n" - "module bar;\n" - "endmodule\n" - "`else // different unit\n" - "module baz;\n" - "endmodule\n" - "`endif\n"}, - - // unary: + - ! ~ & | ^ ~& ~| ~^ ^~ - {"module m;foo bar(.x(-{a,b}));endmodule", - "module m;\n" - " foo bar (.x(-{a, b}));\n" - "endmodule\n"}, - {"module m;foo bar(.x(!{a,b}));endmodule", - "module m;\n" - " foo bar (.x(!{a, b}));\n" - "endmodule\n"}, - {"module m;foo bar(.x(~{a,b}));endmodule", - "module m;\n" - " foo bar (.x(~{a, b}));\n" - "endmodule\n"}, - {"module m;foo bar(.x(&{a,b}));endmodule", - "module m;\n" - " foo bar (.x(&{a, b}));\n" - "endmodule\n"}, - {"module m;foo bar(.x(|{a,b}));endmodule", - "module m;\n" - " foo bar (.x(|{a, b}));\n" - "endmodule\n"}, - {"module m;foo bar(.x(^{a,b}));endmodule", - "module m;\n" - " foo bar (.x(^{a, b}));\n" - "endmodule\n"}, - {"module m;foo bar(.x(~&{a,b}));endmodule", - "module m;\n" - " foo bar (.x(~&{a, b}));\n" - "endmodule\n"}, - {"module m;foo bar(.x(~|{a,b}));endmodule", - "module m;\n" - " foo bar (.x(~|{a, b}));\n" - "endmodule\n"}, - {"module m;foo bar(.x(~^{a,b}));endmodule", - "module m;\n" - " foo bar (.x(~^{a, b}));\n" - "endmodule\n"}, - {"module m;foo bar(.x(^~{a,b}));endmodule", - "module m;\n" - " foo bar (.x(^~{a, b}));\n" - "endmodule\n"}, - - // binary: + - * / % & | ^ ^~ ~^ && || - {"module m;foo bar(.x(a+b));endmodule", - "module m;\n" - " foo bar (.x(a + b));\n" - "endmodule\n"}, - {"module m;foo bar(.x(a-b));endmodule", - "module m;\n" - " foo bar (.x(a - b));\n" - "endmodule\n"}, - {"module m;foo bar(.x(a*b));endmodule", - "module m;\n" - " foo bar (.x(a * b));\n" - "endmodule\n"}, - {"module m;foo bar(.x(a/b));endmodule", - "module m;\n" - " foo bar (.x(a / b));\n" - "endmodule\n"}, - {"module m;foo bar(.x(a%b));endmodule", - "module m;\n" - " foo bar (.x(a % b));\n" - "endmodule\n"}, - {"module m;foo bar(.x(a&b));endmodule", - "module m;\n" - " foo bar (.x(a & b));\n" - "endmodule\n"}, - {"module m;foo bar(.x(a|b));endmodule", - "module m;\n" - " foo bar (.x(a | b));\n" - "endmodule\n"}, - {"module m;foo bar(.x(a^b));endmodule", - "module m;\n" - " foo bar (.x(a ^ b));\n" - "endmodule\n"}, - {"module m;foo bar(.x(a^~b));endmodule", - "module m;\n" - " foo bar (.x(a ^~ b));\n" - "endmodule\n"}, - {"module m;foo bar(.x(a~^b));endmodule", - "module m;\n" - " foo bar (.x(a ~^ b));\n" - "endmodule\n"}, - {"module m;foo bar(.x(a&&b));endmodule", - "module m;\n" - " foo bar (.x(a && b));\n" - "endmodule\n"}, - {"module m;foo bar(.x(a||b));endmodule", - "module m;\n" - " foo bar (.x(a || b));\n" - "endmodule\n"}, - - // {a} op {b} - {"module m;foo bar(.x({a}+{b}));endmodule", - "module m;\n" - " foo bar (.x({a} + {b}));\n" - "endmodule\n"}, - {"module m;foo bar(.x({a}-{b}));endmodule", - "module m;\n" - " foo bar (.x({a} - {b}));\n" - "endmodule\n"}, - {"module m;foo bar(.x({a}*{b}));endmodule", - "module m;\n" - " foo bar (.x({a} * {b}));\n" - "endmodule\n"}, - {"module m;foo bar(.x({a}/{b}));endmodule", - "module m;\n" - " foo bar (.x({a} / {b}));\n" - "endmodule\n"}, - {"module m;foo bar(.x({a}%{b}));endmodule", - "module m;\n" - " foo bar (.x({a} % {b}));\n" - "endmodule\n"}, - {"module m;foo bar(.x({a}&{b}));endmodule", - "module m;\n" - " foo bar (.x({a} & {b}));\n" - "endmodule\n"}, - {"module m;foo bar(.x({a}|{b}));endmodule", - "module m;\n" - " foo bar (.x({a} | {b}));\n" - "endmodule\n"}, - {"module m;foo bar(.x({a}^{b}));endmodule", - "module m;\n" - " foo bar (.x({a} ^ {b}));\n" - "endmodule\n"}, - {"module m;foo bar(.x({a}^~{b}));endmodule", - "module m;\n" - " foo bar (.x({a} ^~ {b}));\n" - "endmodule\n"}, - {"module m;foo bar(.x({a}~^{b}));endmodule", - "module m;\n" - " foo bar (.x({a} ~^ {b}));\n" - "endmodule\n"}, - {"module m;foo bar(.x({a}&&{b}));endmodule", - "module m;\n" - " foo bar (.x({a} && {b}));\n" - "endmodule\n"}, - {"module m;foo bar(.x({a}||{b}));endmodule", - "module m;\n" - " foo bar (.x({a} || {b}));\n" - "endmodule\n"}, - - // (a) op (b) - {"module m;foo bar(.x((a)+(b)));endmodule", - "module m;\n" - " foo bar (.x((a) + (b)));\n" - "endmodule\n"}, - {"module m;foo bar(.x((a)-(b)));endmodule", - "module m;\n" - " foo bar (.x((a) - (b)));\n" - "endmodule\n"}, - {"module m;foo bar(.x((a)*(b)));endmodule", - "module m;\n" - " foo bar (.x((a) * (b)));\n" - "endmodule\n"}, - {"module m;foo bar(.x((a)/(b)));endmodule", - "module m;\n" - " foo bar (.x((a) / (b)));\n" - "endmodule\n"}, - {"module m;foo bar(.x((a)%(b)));endmodule", - "module m;\n" - " foo bar (.x((a) % (b)));\n" - "endmodule\n"}, - {"module m;foo bar(.x((a)&(b)));endmodule", - "module m;\n" - " foo bar (.x((a) & (b)));\n" - "endmodule\n"}, - {"module m;foo bar(.x((a)|(b)));endmodule", - "module m;\n" - " foo bar (.x((a) | (b)));\n" - "endmodule\n"}, - {"module m;foo bar(.x((a)^(b)));endmodule", - "module m;\n" - " foo bar (.x((a) ^ (b)));\n" - "endmodule\n"}, - {"module m;foo bar(.x((a)^~(b)));endmodule", - "module m;\n" - " foo bar (.x((a) ^~ (b)));\n" - "endmodule\n"}, - {"module m;foo bar(.x((a)~^(b)));endmodule", - "module m;\n" - " foo bar (.x((a) ~^ (b)));\n" - "endmodule\n"}, - {"module m;foo bar(.x((a)&&(b)));endmodule", - "module m;\n" - " foo bar (.x((a) && (b)));\n" - "endmodule\n"}, - {"module m;foo bar(.x((a)||(b)));endmodule", - "module m;\n" - " foo bar (.x((a) || (b)));\n" - "endmodule\n"}, - - // a[b] op c - {"module m;foo bar(.x(a[b]+c));endmodule", - "module m;\n" - " foo bar (.x(a[b] + c));\n" - "endmodule\n"}, - {"module m;foo bar(.x(a[b]-c));endmodule", - "module m;\n" - " foo bar (.x(a[b] - c));\n" - "endmodule\n"}, - {"module m;foo bar(.x(a[b]*c));endmodule", - "module m;\n" - " foo bar (.x(a[b] * c));\n" - "endmodule\n"}, - {"module m;foo bar(.x(a[b]/c));endmodule", - "module m;\n" - " foo bar (.x(a[b] / c));\n" - "endmodule\n"}, - {"module m;foo bar(.x(a[b]%c));endmodule", - "module m;\n" - " foo bar (.x(a[b] % c));\n" - "endmodule\n"}, - {"module m;foo bar(.x(a[b]&c));endmodule", - "module m;\n" - " foo bar (.x(a[b] & c));\n" - "endmodule\n"}, - {"module m;foo bar(.x(a[b]|c));endmodule", - "module m;\n" - " foo bar (.x(a[b] | c));\n" - "endmodule\n"}, - {"module m;foo bar(.x(a[b]^c));endmodule", - "module m;\n" - " foo bar (.x(a[b] ^ c));\n" - "endmodule\n"}, - {"module m;foo bar(.x(a[b]^~c));endmodule", - "module m;\n" - " foo bar (.x(a[b] ^~ c));\n" - "endmodule\n"}, - {"module m;foo bar(.x(a[b]~^c));endmodule", - "module m;\n" - " foo bar (.x(a[b] ~^ c));\n" - "endmodule\n"}, - {"module m;foo bar(.x(a[b]&&c));endmodule", - "module m;\n" - " foo bar (.x(a[b] && c));\n" - "endmodule\n"}, - {"module m;foo bar(.x(a[b]||c));endmodule", - "module m;\n" - " foo bar (.x(a[b] || c));\n" - "endmodule\n"}, - - // misc - {"module m;foo bar(.x(a[1:0]^b[2:1]));endmodule", - "module m;\n" - " foo bar (.x(a[1:0] ^ b[2:1]));\n" - "endmodule\n"}, - - {"module m;foo bar(.x(a[b] | b[c]));endmodule", - "module m;\n" - " foo bar (.x(a[b] | b[c]));\n" - "endmodule\n"}, - {"module m;foo bar(.x(a[b] & b[c]));endmodule", - "module m;\n" - " foo bar (.x(a[b] & b[c]));\n" - "endmodule\n"}, - - {"module m;foo bar(.x((a^c)^(b^ ~c)));endmodule", - "module m;\n" - " foo bar (.x((a ^ c) ^ (b ^ ~c)));\n" - "endmodule\n"}, - {"module m;foo bar(.x((a^c)^(b^~c)));endmodule", - "module m;\n" - " foo bar (.x((a ^ c) ^ (b ^~ c)));\n" - "endmodule\n"}, - {"module m;foo bar(.x((a^{c,d})^(b^^{c,d})));endmodule", - "module m;\n" - " foo bar (\n" - " .x((a ^ {c, d}) ^ (b ^ ^{c, d}))\n" - " );\n" - "endmodule\n"}, - - {// module items mixed with preprocessor conditionals and comments - " module foo;\n" - "// comment1\n" - " `ifdef SIM\n" - "// comment2\n" - " `elsif SYN\n" - " // comment3\n" - " `else\n" - "// comment4\n" - " `endif\n" - "// comment5\n" - " endmodule", - "module foo;\n" - " // comment1\n" - "`ifdef SIM\n" - " // comment2\n" - "`elsif SYN\n" - " // comment3\n" - "`else\n" - " // comment4\n" - "`endif\n" - " // comment5\n" - "endmodule\n"}, - {" module bar;wire foo;reg bear;endmodule\n", - "module bar;\n" - " wire foo;\n" - " reg bear;\n" // aligned - "endmodule\n"}, - {" module bar;initial\nbegin a<=b . c ; end endmodule\n", - "module bar;\n" - " initial begin\n" - " a <= b.c;\n" - " end\n" - "endmodule\n"}, - {"module foo ();\nif (1) begin\n$finish(\n" - " 1 ); $finish ();\n end\nendmodule", - "module foo ();\n" - " if (1) begin\n" - " $finish(1);\n" - " $finish();\n" - " end\n" - "endmodule\n"}, - {" module bar;for(genvar i = 0 ; i<N ; ++ i ) begin end endmodule\n", - "module bar;\n" - " for (genvar i = 0; i < N; ++i) begin\n" - " end\n" - "endmodule\n"}, - {" module bar;for(genvar i = 0 ; i!=N ; i ++ ) begin " - "foo f;end endmodule\n", - "module bar;\n" - " for (genvar i = 0; i != N; i++) begin\n" - " foo f;\n" - " end\n" - "endmodule\n"}, - { - "module block_generate;\n" - "`ASSERT(blah)\n" - "generate endgenerate endmodule\n", - "module block_generate;\n" - " `ASSERT(blah)\n" - " generate\n" - " endgenerate\n" - "endmodule\n", - }, - { - "module conditional_generate;\n" - "if(foo) ; \t" // null action - "endmodule\n", - "module conditional_generate;\n" - " if (foo);\n" - "endmodule\n", - }, - { - "module conditional_generate;\n" - "if(foo[a*b+c]) ; \t" // null action - "endmodule\n", - "module conditional_generate;\n" - " if (foo[a*b+c]);\n" // allow compact expressions inside [] - "endmodule\n", - }, - { - "module conditional_generate;\n" - "if(foo)begin\n" - "`ASSERT()\n" - "`COVER()\n" - " end\n" - "endmodule\n", - "module conditional_generate;\n" - " if (foo) begin\n" - " `ASSERT()\n" - " `COVER()\n" - " end\n" - "endmodule\n", - }, - { - "module conditional_generate;\n" - "`ASSERT()\n" - "if(foo)begin\n" - " end\n" - "`COVER()\n" - "endmodule\n", - "module conditional_generate;\n" - " `ASSERT()\n" - " if (foo) begin\n" - " end\n" - " `COVER()\n" - "endmodule\n", - }, - { - "module conditional_generate;\n" - "if(foo)begin\n" - " // comment1\n" - " // comment2\n" - " end\n" - "endmodule\n", - "module conditional_generate;\n" - " if (foo) begin\n" - " // comment1\n" - " // comment2\n" - " end\n" - "endmodule\n", - }, - { - "module m ;" - "for(genvar i=0; ;)\n; " // null generate statement - "for(genvar j=0 ;; )\n; " // null generate statement - "endmodule", - "module m;\n" - " for (genvar i = 0;;);\n" - " for (genvar j = 0;;);\n" - "endmodule\n", - }, - { - "module m ;" - "for (genvar f = 0; f < N; f++) begin " - "assign x = y; assign y = z;" - "end endmodule", - "module m;\n" - " for (genvar f = 0; f < N; f++) begin\n" - " assign x = y;\n" - " assign y = z;\n" - " end\n" - "endmodule\n", - }, - { - // standalone genvar statement - "module m ;" - "genvar f;" - "for(f=0; f<N; f ++ )begin " - "end endmodule", - "module m;\n" - " genvar f;\n" - " for (f = 0; f < N; f++) begin\n" - " end\n" - "endmodule\n", - }, - { - // multiple arguments to genvar statement - "module m ;" - "genvar f, g;" - "for(f=0; f<N; f ++ )begin " - "end for(g=N; g>0; g -- )begin " - "end endmodule", - "module m;\n" - " genvar f, g;\n" - " for (f = 0; f < N; f++) begin\n" - " end\n" - " for (g = N; g > 0; g--) begin\n" - " end\n" - "endmodule\n", - }, - { - // multiple genvar statements - "module m ;" - "genvar f;" - "genvar g;" - "for(f=0; f<N; f ++ )begin " - "end for(g=N; g>0; g -- )begin " - "end endmodule", - "module m;\n" - " genvar f;\n" - " genvar g;\n" - " for (f = 0; f < N; f++) begin\n" - " end\n" - " for (g = N; g > 0; g--) begin\n" - " end\n" - "endmodule\n", - }, - { - "module event_control ;" - "always@ ( posedge clk )z<=y;" - "endmodule\n", - "module event_control;\n" - " always @(posedge clk) z <= y;\n" - "endmodule\n", - }, - { - "module always_if ;" - "always@ ( posedge clk ) if (expr) z<=y;" - "endmodule\n", - "module always_if;\n" - " always @(posedge clk)\n" // doesn't fit - " if (expr)\n" - " z <= y;\n" - "endmodule\n", - }, - { - "module always_if ;" - "always@* if (expr) z<=y;" - "endmodule\n", - "module always_if;\n" - " always @* if (expr) z <= y;\n" // fits - "endmodule\n", - }, - { - "module \talways_if_else ;" - "always@* if (expr) z<=y; else g<=0;" - "endmodule\n", - "module always_if_else;\n" - " always @*\n" - " if (expr) z <= y;\n" // fits - " else g <= 0;\n" // fits - "endmodule\n", - }, - { - "module \talways_if_else_if ;" - "always@* if (expr) z<=y; else if (w) g<=0;" - "endmodule\n", - "module always_if_else_if;\n" - " always @*\n" - " if (expr) z <= y;\n" // fits - " else if (w) g <= 0;\n" // fits - "endmodule\n", - }, - { - "module \talways_if_else_if_else ;" - "always@* if (expr) z<=y; else if (w) g<=0;else h<=1;" - "endmodule\n", - "module always_if_else_if_else;\n" - " always @*\n" - " if (expr) z <= y;\n" // fits - " else if (w) g <= 0;\n" // fits - " else h <= 1;\n" - "endmodule\n", - }, - { - "module m;\n" - "always @(b, c)" - " for (;;)\ts = y;" - "endmodule", - "module m;\n" - " always @(b, c) for (;;) s = y;\n" // fits - "endmodule\n", - }, - { - "module m;\n" - "always @(posedge clk)" - " for (i=0;i<k;++i)\ts = y;" - "endmodule", - "module m;\n" - " always @(posedge clk)\n" - " for (i = 0; i < k; ++i)\n" - " s = y;\n" - "endmodule\n", - }, - { - "module m;\n" - "always @(posedge clk)" - " repeat (jj+kk)\ts = y;" - "endmodule", - "module m;\n" - " always @(posedge clk)\n" - " repeat (jj + kk)\n" - " s = y;\n" - "endmodule\n", - }, - { - "module m;\n" - "always @(posedge clk)" - " foreach(jj[kk])\ts = y;" - "endmodule", - "module m;\n" - " always @(posedge clk)\n" - " foreach (jj[kk])\n" - " s = y;\n" - "endmodule\n", - }, - { - "module m;\n" - "always @(posedge clk)" - " while(jj[kk])\ts = y;" - "endmodule", - "module m;\n" - " always @(posedge clk)\n" - " while (jj[kk])\n" - " s = y;\n" - "endmodule\n", - }, - { - "module m;\n" - "always @(posedge clk)" - " do s=y;while(jj[kk]);\t" - "endmodule", - "module m;\n" - " always @(posedge clk)\n" - " do\n" - " s = y;\n" - " while (jj[kk]);\n" - "endmodule\n", - }, - { - "module m;\n" - "always @(posedge clk) \n" - " case(jj)\tS:s = y;endcase\t" - "endmodule", - "module m;\n" - " always @(posedge clk)\n" - " case (jj)\n" - " S: s = y;\n" - " endcase\n" - "endmodule\n", - }, - - { - "module always_if ;" - "always@ ( posedge clk ) if (expr) z<=y;" - "endmodule\n", - "module always_if;\n" - " always @(posedge clk)\n" // doesn't fit - " if (expr)\n" - " z <= y;\n" - "endmodule\n", - }, - { - "module always_if ;" - "always@* if (expr) z<=y;" - "endmodule\n", - "module always_if;\n" - " always @* if (expr) z <= y;\n" // fits - "endmodule\n", - }, - { - "module \talways_if_else ;" - "always@* if (expr) z<=y; else g<=0;" - "endmodule\n", - "module always_if_else;\n" - " always @*\n" - " if (expr) z <= y;\n" // fits - " else g <= 0;\n" // fits - "endmodule\n", - }, - { - "module \talways_if_else_if ;" - "always@* if (expr) z<=y; else if (w) g<=0;" - "endmodule\n", - "module always_if_else_if;\n" - " always @*\n" - " if (expr) z <= y;\n" // fits - " else if (w) g <= 0;\n" // fits - "endmodule\n", - }, - { - "module \talways_if_else_if_else ;" - "always@* if (expr) z<=y; else if (w) g<=0;else h<=1;" - "endmodule\n", - "module always_if_else_if_else;\n" - " always @*\n" - " if (expr) z <= y;\n" // fits - " else if (w) g <= 0;\n" // fits - " else h <= 1;\n" - "endmodule\n", - }, - { - "module m;\n" - "always @(b, c)" - " for (;;)\ts = y;" - "endmodule", - "module m;\n" - " always @(b, c) for (;;) s = y;\n" // fits - "endmodule\n", - }, - { - "module m;\n" - "always @(posedge clk)" - " for (i=0;i<k;++i)\ts = y;" - "endmodule", - "module m;\n" - " always @(posedge clk)\n" - " for (i = 0; i < k; ++i)\n" - " s = y;\n" - "endmodule\n", - }, - { - "module m;\n" - "always @(posedge clk)" - " repeat (jj+kk)\ts = y;" - "endmodule", - "module m;\n" - " always @(posedge clk)\n" - " repeat (jj + kk)\n" - " s = y;\n" - "endmodule\n", - }, - { - "module m;\n" - "always @(posedge clk)" - " foreach(jj[kk])\ts = y;" - "endmodule", - "module m;\n" - " always @(posedge clk)\n" - " foreach (jj[kk])\n" - " s = y;\n" - "endmodule\n", - }, - { - "module m;\n" - "always @(posedge clk)" - " while(jj[kk])\ts = y;" - "endmodule", - "module m;\n" - " always @(posedge clk)\n" - " while (jj[kk])\n" - " s = y;\n" - "endmodule\n", - }, - { - "module m;\n" - "always @(posedge clk)" - " do s=y;while(jj[kk]);\t" - "endmodule", - "module m;\n" - " always @(posedge clk)\n" - " do\n" - " s = y;\n" - " while (jj[kk]);\n" - "endmodule\n", - }, - { - "module m;\n" - "always @(posedge clk) \n" - " case(jj)\tS:s = y;endcase\t" - "endmodule", - "module m;\n" - " always @(posedge clk)\n" - " case (jj)\n" - " S: s = y;\n" - " endcase\n" - "endmodule\n", - }, - - { - "module always_if ;" - "always@ ( posedge clk ) if (expr) z<=y;" - "endmodule\n", - "module always_if;\n" - " always @(posedge clk)\n" // doesn't fit - " if (expr)\n" - " z <= y;\n" - "endmodule\n", - }, - { - "module always_if ;" - "always@* if (expr) z<=y;" - "endmodule\n", - "module always_if;\n" - " always @* if (expr) z <= y;\n" // fits - "endmodule\n", - }, - { - "module \talways_if_else ;" - "always@* if (expr) z<=y; else g<=0;" - "endmodule\n", - "module always_if_else;\n" - " always @*\n" - " if (expr) z <= y;\n" // fits - " else g <= 0;\n" // fits - "endmodule\n", - }, - { - "module \talways_if_else_if ;" - "always@* if (expr) z<=y; else if (w) g<=0;" - "endmodule\n", - "module always_if_else_if;\n" - " always @*\n" - " if (expr) z <= y;\n" // fits - " else if (w) g <= 0;\n" // fits - "endmodule\n", - }, - { - "module \talways_if_else_if_else ;" - "always@* if (expr) z<=y; else if (w) g<=0;else h<=1;" - "endmodule\n", - "module always_if_else_if_else;\n" - " always @*\n" - " if (expr) z <= y;\n" // fits - " else if (w) g <= 0;\n" // fits - " else h <= 1;\n" - "endmodule\n", - }, - { - "module m;\n" - "always @(b, c)" - " for (;;)\ts = y;" - "endmodule", - "module m;\n" - " always @(b, c) for (;;) s = y;\n" // fits - "endmodule\n", - }, - { - "module m;\n" - "always @(posedge clk)" - " for (i=0;i<k;++i)\ts = y;" - "endmodule", - "module m;\n" - " always @(posedge clk)\n" - " for (i = 0; i < k; ++i)\n" - " s = y;\n" - "endmodule\n", - }, - { - "module m;\n" - "always @(posedge clk)" - " repeat (jj+kk)\ts = y;" - "endmodule", - "module m;\n" - " always @(posedge clk)\n" - " repeat (jj + kk)\n" - " s = y;\n" - "endmodule\n", - }, - { - "module m;\n" - "always @(posedge clk)" - " foreach(jj[kk])\ts = y;" - "endmodule", - "module m;\n" - " always @(posedge clk)\n" - " foreach (jj[kk])\n" - " s = y;\n" - "endmodule\n", - }, - { - "module m;\n" - "always @(posedge clk)" - " while(jj[kk])\ts = y;" - "endmodule", - "module m;\n" - " always @(posedge clk)\n" - " while (jj[kk])\n" - " s = y;\n" - "endmodule\n", - }, - { - "module m;\n" - "always @(posedge clk)" - " do s=y;while(jj[kk]);\t" - "endmodule", - "module m;\n" - " always @(posedge clk)\n" - " do\n" - " s = y;\n" - " while (jj[kk]);\n" - "endmodule\n", - }, - { - "module m;\n" - "always @(posedge clk) \n" - " case(jj)\tS:s = y;endcase\t" - "endmodule", - "module m;\n" - " always @(posedge clk)\n" - " case (jj)\n" - " S: s = y;\n" - " endcase\n" - "endmodule\n", - }, - - { - "module always_if ;" - "always@ ( posedge clk ) if (expr) z<=y;" - "endmodule\n", - "module always_if;\n" - " always @(posedge clk)\n" // doesn't fit - " if (expr)\n" - " z <= y;\n" - "endmodule\n", - }, - { - "module always_if ;" - "always@* if (expr) z<=y;" - "endmodule\n", - "module always_if;\n" - " always @* if (expr) z <= y;\n" // fits - "endmodule\n", - }, - { - "module \talways_if_else ;" - "always@* if (expr) z<=y; else g<=0;" - "endmodule\n", - "module always_if_else;\n" - " always @*\n" - " if (expr) z <= y;\n" // fits - " else g <= 0;\n" // fits - "endmodule\n", - }, - { - "module \talways_if_else_if ;" - "always@* if (expr) z<=y; else if (w) g<=0;" - "endmodule\n", - "module always_if_else_if;\n" - " always @*\n" - " if (expr) z <= y;\n" // fits - " else if (w) g <= 0;\n" // fits - "endmodule\n", - }, - { - "module \talways_if_else_if_else ;" - "always@* if (expr) z<=y; else if (w) g<=0;else h<=1;" - "endmodule\n", - "module always_if_else_if_else;\n" - " always @*\n" - " if (expr) z <= y;\n" // fits - " else if (w) g <= 0;\n" // fits - " else h <= 1;\n" - "endmodule\n", - }, - { - "module m;\n" - "always @(b, c)" - " for (;;)\ts = y;" - "endmodule", - "module m;\n" - " always @(b, c) for (;;) s = y;\n" // fits - "endmodule\n", - }, - { - "module m;\n" - "always @(posedge clk)" - " for (i=0;i<k;++i)\ts = y;" - "endmodule", - "module m;\n" - " always @(posedge clk)\n" - " for (i = 0; i < k; ++i)\n" - " s = y;\n" - "endmodule\n", - }, - { - "module m;\n" - "always @(posedge clk)" - " repeat (jj+kk)\ts = y;" - "endmodule", - "module m;\n" - " always @(posedge clk)\n" - " repeat (jj + kk)\n" - " s = y;\n" - "endmodule\n", - }, - { - "module m;\n" - "always @(posedge clk)" - " foreach(jj[kk])\ts = y;" - "endmodule", - "module m;\n" - " always @(posedge clk)\n" - " foreach (jj[kk])\n" - " s = y;\n" - "endmodule\n", - }, - { - "module m;\n" - "always @(posedge clk)" - " while(jj[kk])\ts = y;" - "endmodule", - "module m;\n" - " always @(posedge clk)\n" - " while (jj[kk])\n" - " s = y;\n" - "endmodule\n", - }, - { - "module m;\n" - "always @(posedge clk)" - " do s=y;while(jj[kk]);\t" - "endmodule", - "module m;\n" - " always @(posedge clk)\n" - " do\n" - " s = y;\n" - " while (jj[kk]);\n" - "endmodule\n", - }, - { - "module m;\n" - "always @(posedge clk) \n" - " case(jj)\tS:s = y;endcase\t" - "endmodule", - "module m;\n" - " always @(posedge clk)\n" - " case (jj)\n" - " S: s = y;\n" - " endcase\n" - "endmodule\n", - }, - - { - // begin/end with labels - "module m ;initial begin:yyy\tend:yyy endmodule", - "module m;\n" - " initial begin : yyy\n" - " end : yyy\n" - "endmodule\n", - }, - { - // conditional generate begin/end with labels - "module m ;if\n( 1) begin:yyy\tend:yyy endmodule", - "module m;\n" - " if (1) begin : yyy\n" - " end : yyy\n" - "endmodule\n", - }, - { - // begin/end with labels, nested - "module m ;initial begin:yyy if(1)begin:zzz " - "end:zzz\tend:yyy endmodule", - "module m;\n" - " initial begin : yyy\n" - " if (1) begin : zzz\n" - " end : zzz\n" - " end : yyy\n" - "endmodule\n", - }, - { - "module m ;initial begin # 1 x<=y ;end endmodule", - "module m;\n" - " initial begin\n" - " #1 x <= y;\n" - " end\n" - "endmodule\n", - }, - { - "module m ;initial begin x<=y ; y<=z;end endmodule", - "module m;\n" - " initial begin\n" - " x <= y;\n" - " y <= z;\n" - " end\n" - "endmodule\n", - }, - { - "module m ;initial begin # 10 x<=y ; # 20 y<=z;end endmodule", - "module m;\n" - " initial begin\n" - " #10 x <= y;\n" - " #20 y <= z;\n" - " end\n" - "endmodule\n", - }, - { - // qualified variables - "module m ;initial begin automatic int a; " - " static byte s=0;end endmodule", - "module m;\n" - " initial begin\n" - " automatic int a;\n" - " static byte s = 0;\n" // aligned - " end\n" - "endmodule\n", - }, - { - "module m ;initial begin automatic int a,b; " - " static byte s,t;end endmodule", - "module m;\n" - " initial begin\n" - " automatic int a, b;\n" - " static byte s, t;\n" - " end\n" - "endmodule\n", - }, - { - "module m ;initial begin static byte a=1,b=0;end endmodule", - "module m;\n" - " initial begin\n" - " static byte a = 1, b = 0;\n" - " end\n" - "endmodule\n", - }, - { - "module m ;initial begin const int a=0;end endmodule", - "module m;\n" - " initial begin\n" - " const int a = 0;\n" - " end\n" - "endmodule\n", - }, - { - "module m ;initial begin automatic const int a=0;end endmodule", - "module m;\n" - " initial begin\n" - " automatic const int a = 0;\n" - " end\n" - "endmodule\n", - }, - { - "module m ;initial begin const var automatic int a=0;end endmodule", - "module m;\n" - " initial begin\n" - " const var automatic int a = 0;\n" - " end\n" - "endmodule\n", - }, - { - "module m ;initial begin static byte s ={<<{a}};end endmodule", - "module m;\n" - " initial begin\n" - " static byte s = {<<{a}};\n" - " end\n" - "endmodule\n", - }, - { - "module m ;initial begin static int s ={>>4{a}};end endmodule", - "module m;\n" - " initial begin\n" - " static int s = {>>4{a}};\n" - " end\n" - "endmodule\n", - }, - { - "module m; final assert (expr ) ;endmodule", - "module m;\n" - " final assert (expr);\n" - "endmodule\n", - }, - { - "module m; final begin\tassert (expr ) ;end endmodule", - "module m;\n" - " final begin\n" - " assert (expr);\n" - " end\n" - "endmodule\n", - }, - { - "module m; final assume (expr ) ;endmodule", - "module m;\n" - " final assume (expr);\n" - "endmodule\n", - }, - { - "module m; final cover (expr ) ;endmodule", - "module m;\n" - " final cover (expr);\n" - "endmodule\n", - }, - { - // two consecutive clocking declarations in modules - " module mcd ; " - "clocking cb @( posedge clk);\t\tendclocking " - "clocking cb2 @ (posedge clk\n); endclocking endmodule", - "module mcd;\n" - " clocking cb @(posedge clk);\n" - " endclocking\n" - " clocking cb2 @(posedge clk);\n" - " endclocking\n" - "endmodule\n", - }, - { - // two consecutive clocking declarations in modules, with end labels - " module mcd ; " - "clocking cb @( posedge clk);\t\tendclocking: cb " - "clocking cb2 @ (posedge clk\n); endclocking :cb2 endmodule", - "module mcd;\n" - " clocking cb @(posedge clk);\n" - " endclocking : cb\n" - " clocking cb2 @(posedge clk);\n" - " endclocking : cb2\n" - "endmodule\n", - }, - { - // clocking declarations with ports in modules - " module mcd ; " - "clocking cb @ (posedge clk\n); input a; output b; endclocking " - "endmodule", - "module mcd;\n" - " clocking cb @(posedge clk);\n" - " input a;\n" - " output b;\n" - " endclocking\n" - "endmodule\n", - }, - { - // DPI import declarations in modules - "module mdi;" - "import \"DPI-C\" function int add(\n) ;" - "import \"DPI-C\"\t\tfunction int\nsleep( input int secs );" - "import \"DPI-C\"\t\tfunction int\nwake( input int secs, output bit " - "[2:0] z);" - "endmodule", - "module mdi;\n" - " import \"DPI-C\" function int add();\n" - " import \"DPI-C\" function int sleep(\n" - " input int secs\n" - " );\n" - " import \"DPI-C\" function int wake(\n" - " input int secs,\n" - " output bit [2:0] z\n" - " );\n" - "endmodule\n", - }, - { - // DPI export declarations in modules - "module m;" - "export \"DPI-C\" function get;" - "export \"DPI-C\" function mhpmcounter_get;\n" - "export \"DPI-C\"\t\tfunction int\nwake( input int secs, output bit " - "[2:0] z);" - "endmodule", - "module m;\n" - " export \"DPI-C\" function get;\n" - " export \"DPI-C\"\n" - " function mhpmcounter_get;\n" // doesn't fit in 40-col - " export \"DPI-C\" function int wake(\n" - " input int secs,\n" - " output bit [2:0] z\n" - " );\n" - "endmodule\n", - }, - {// Two consecutive EOL comments in kDPIImportItem - "import \"DPI-C\" context function void foo(\n" - " input bit first,\n" - " // c3\n" - " // c3+\n" - " input bit second\n" - ");\n", - "import \"DPI-C\" context\n" - " function void foo(\n" - " input bit first,\n" - " // c3\n" - " // c3+\n" - " input bit second\n" - ");\n"}, - {"export \"\" t;\n", "export \"\" t;\n"}, - {"import \"DPI-C\" context function void func(input bit impl_i," - "input bit op_i," - "input bit [5:0] mode_i," - "input bit [3:0][31:0] iv_i," - "input bit [2:0] key_len_i," - "input bit [7:0][31:0] key_i," - "input bit [7:0] data_i[]," - "output bit [7:0] data_o[]);", - "import \"DPI-C\" context\n" - " function void func(\n" - " input bit impl_i,\n" - " input bit op_i,\n" - " input bit [5:0] mode_i,\n" - " input bit [3:0][31:0] iv_i,\n" - " input bit [2:0] key_len_i,\n" - " input bit [7:0][31:0] key_i,\n" - " input bit [7:0] data_i [],\n" - " output bit [7:0] data_o []\n" - ");\n"}, - {// module with system task call w or w/o parentheses - "module m; initial begin #10 $display(\"foo\"); $display(\"bar\");" - "end endmodule", - "module m;\n" - " initial begin\n" - " #10 $display(\"foo\");\n" - " $display(\"bar\");\n" - " end\n" - "endmodule\n"}, - {// module with system task call - "module m; initial begin #10 $display; $display;" - "end endmodule", - "module m;\n" - " initial begin\n" - " #10 $display;\n" - " $display;\n" - " end\n" - "endmodule\n"}, - - // interface test cases - {// two interface declarations - " interface if1 ; endinterface\t\t" - "interface if2; endinterface ", - "interface if1;\n" - "endinterface\n" - "interface if2;\n" - "endinterface\n"}, - {// two interface declarations, end labels - " interface if1 ; endinterface:if1\t\t" - "interface if2; endinterface : if2 ", - "interface if1;\n" - "endinterface : if1\n" - "interface if2;\n" - "endinterface : if2\n"}, - {// interface declaration with parameters - " interface if1#( parameter int W= 8 );endinterface\t\t", - "interface if1 #(\n" - " parameter int W = 8\n" - ");\n" - "endinterface\n"}, - {// interface declaration with ports (empty) - " interface if1()\n;endinterface\t\t", - "interface if1 ();\n" - "endinterface\n"}, - {// interface declaration with parameter comment only, empty ports - " interface if1#( \n" - "//param\n" - ")();endinterface\t\t", - "interface if1 #(\n" - " //param\n" - ") ();\n" - "endinterface\n"}, - {// interface declaration with parameter, empty ports - " interface if1#( parameter int W= 8 )();endinterface\t\t", - "interface if1 #(\n" - " parameter int W = 8\n" - ") ();\n" - "endinterface\n"}, - {// interface declaration with ports - " interface if1( input\tlogic z)\n;endinterface\t\t", - "interface if1 (\n" - " input logic z\n" - ");\n" - "endinterface\n"}, - {// interface declaration with multiple ports - " interface if1( input\tlogic z, output logic a)\n;endinterface\t\t", - "interface if1 (\n" - " input logic z,\n" // should be one-per-line, even it it fits - " output logic a\n" // aligned - ");\n" - "endinterface\n"}, - {// interface declaration with parameters and ports - " interface if1#( parameter int W= 8 )(input logic z);endinterface\t\t", - // doesn't fit on one line - "interface if1 #(\n" - " parameter int W = 8\n" - ") (\n" - " input logic z\n" - ");\n" - "endinterface\n"}, - { - // interface with modport declarations - "interface\tfoo_if ;" - "modport mp1\t( output a, input b);" - "modport\tmp2 (output c,input d );\t" - "endinterface", - "interface foo_if;\n" - " modport mp1(output a, input b);\n" - " modport mp2(output c, input d);\n" - "endinterface\n", - }, - { - // interface with long modport port names - "interface\tfoo_if ;" - "modport mp1\t( output a_long_output, input detailed_input_name);" - "endinterface", - "interface foo_if;\n" - " modport mp1(\n" - " output a_long_output,\n" - " input detailed_input_name\n" - " );\n" - "endinterface\n", - }, - { - // interface with modport declaration with multiple ports - "interface\tfoo_if ;" - "modport mp1\t( output a_long_output, input detailed_input_name);" - "endinterface", - "interface foo_if;\n" - " modport mp1(\n" - " output a_long_output,\n" - " input detailed_input_name\n" - " );\n" - "endinterface\n", - }, - { - // interface with modport TF port declaration - "interface\tfoo_if ;" - "modport mp1\t( output a, input b, import c);" - "endinterface", - "interface foo_if;\n" - " modport mp1(\n" - " output a,\n" - " input b,\n" - " import c\n" - " );\n" - "endinterface\n", - }, - { - // interface with complex modport ports list - "interface\tfoo_if ;" - "modport producer\t(input ready,\toutput data, valid, user," - " strobe, keep, last,\timport producer_reset, producer_tick);" - "modport consumer\t(input data, valid, user, strobe, keep, last," - " output ready,\timport consumer_reset, consumer_tick, consume);" - "endinterface", - "interface foo_if;\n" - " modport producer(\n" - " input ready,\n" - " output data, valid, user, strobe,\n" - " keep, last,\n" - " import producer_reset,\n" - " producer_tick\n" - " );\n" - " modport consumer(\n" - " input data, valid, user, strobe,\n" - " keep, last,\n" - " output ready,\n" - " import consumer_reset,\n" - " consumer_tick, consume\n" - " );\n" - "endinterface\n", - }, - { - // interface with modports and comments inside - "interface foo_if;\n" - " modport mp1(\n" - " // Our output\n" - " output a,\n" - " /* Inputs */\n" - " input b1, b_f /*last*/," - " import c\n" - " );\n" - "endinterface\n", - "interface foo_if;\n" - " modport mp1(\n" - " // Our output\n" - " output a,\n" - " /* Inputs */\n" - " input b1, b_f /*last*/,\n" - " import c\n" - " );\n" - "endinterface\n", - }, - - // class test cases - {"class action;int xyz;endclass : action\n", - "class action;\n" - " int xyz;\n" - "endclass : action\n"}, - {"class action extends mypkg :: inaction;endclass : action\n", - "class action extends mypkg::inaction;\n" // tests for spacing around :: - "endclass : action\n"}, - {"class c;function new;endfunction endclass", - "class c;\n" - " function new;\n" - " endfunction\n" - "endclass\n"}, - {"class c;function new ( );endfunction endclass", - "class c;\n" - " function new();\n" - " endfunction\n" - "endclass\n"}, - {"class c;function new ( string s );endfunction endclass", - "class c;\n" - " function new(string s);\n" - " endfunction\n" - "endclass\n"}, - {"class c;function new ( string s ,int i );endfunction endclass", - "class c;\n" - " function new(string s, int i);\n" - " endfunction\n" - "endclass\n"}, - {"class c;function void f;endfunction endclass", - "class c;\n" - " function void f;\n" - " endfunction\n" - "endclass\n"}, - {"class c;virtual function void f;endfunction endclass", - "class c;\n" - " virtual function void f;\n" - " endfunction\n" - "endclass\n"}, - {"class c;function int f ( );endfunction endclass", - "class c;\n" - " function int f();\n" - " endfunction\n" - "endclass\n"}, - {"class c;function int f ( int ii );endfunction endclass", - "class c;\n" - " function int f(int ii);\n" - " endfunction\n" - "endclass\n"}, - {"class c;function int f ( int ii ,bit bb );endfunction endclass", - "class c;\n" - " function int f(int ii, bit bb);\n" - " endfunction\n" - "endclass\n"}, - {"class c;task t ;endtask endclass", - "class c;\n" - " task t;\n" - " endtask\n" - "endclass\n"}, - {"class c;task t ( int ii ,bit bb );endtask endclass", - "class c;\n" - " task t(int ii, bit bb);\n" - " endtask\n" - "endclass\n"}, - {"class c; task automatic repeated_assigner;" - "repeat (count) y = w;" // single statement body - "endtask endclass", - "class c;\n" - " task automatic repeated_assigner;\n" - " repeat (count) y = w;\n" - " endtask\n" - "endclass\n"}, - {"class c; task automatic delayed_assigner;" - "# 100 y = w;" // delayed assignment - "endtask endclass", - "class c;\n" - " task automatic delayed_assigner;\n" - " #100 y = w;\n" - " endtask\n" - "endclass\n"}, - {"class c; task automatic labeled_assigner;" - "lbl : y = w;" // delayed assignment - "endtask endclass", - "class c;\n" - " task automatic labeled_assigner;\n" - " lbl : y = w;\n" // TODO(fangism): no space before ':' - " endtask\n" - "endclass\n"}, - // task with macro call - {"module m1;\ntask automatic t1();\n" - "t2(`R1(1)+ 8);endtask : t1\nendmodule", - "module m1;\n" - " task automatic t1();\n" - " t2(`R1(1) + 8);\n" - " endtask : t1\n" - "endmodule\n"}, - - // tasks with control statements - {"class c; task automatic waiter;" - "if (count == 0) begin #0; return;end " - "endtask endclass", - "class c;\n" - " task automatic waiter;\n" - " if (count == 0) begin\n" - " #0;\n" - " return;\n" - " end\n" - " endtask\n" - "endclass\n"}, - {"class c; task automatic heartbreaker;" - "if( c)if( d) break ;" - "endtask endclass", - "class c;\n" - " task automatic heartbreaker;\n" - " if (c) if (d) break;\n" - " endtask\n" - "endclass\n"}, - {"class c; task automatic waiter;" - "repeat (count) @(posedge clk);" - "endtask endclass", - "class c;\n" - " task automatic waiter;\n" - " repeat (count) @(posedge clk);\n" - " endtask\n" - "endclass\n"}, - {"class c; task automatic repeat_assigner;" - "repeat( r )\ny = w;" - "repeat( q )\ny = 1;" - "endtask endclass", - "class c;\n" - " task automatic repeat_assigner;\n" - " repeat (r) y = w;\n" - " repeat (q) y = 1;\n" - " endtask\n" - "endclass\n"}, - {"class c; task automatic event_control_assigner;" - "@ ( posedge clk )\ny = w;" - "@ ( negedge clk )\nz = w;" - "endtask endclass", - "class c;\n" - " task automatic event_control_assigner;\n" - " @(posedge clk) y = w;\n" - " @(negedge clk) z = w;\n" - " endtask\n" - "endclass\n"}, - { - // classes with surrrounding comments - // vertical spacing preserved - "\n// pre-c\n\n" - " class c ;\n" - "// c stuff\n" - "endclass\n" - " // pre-d\n" - "\n\nclass d ;\n" - " // d stuff\n" - "endclass\n" - "\n// the end\n", - "\n// pre-c\n\n" - "class c;\n" - " // c stuff\n" - "endclass\n" - "// pre-d\n\n\n" - "class d;\n" - " // d stuff\n" - "endclass\n\n" - "// the end\n", - }, - {// class with comments around task/function declarations - "class c; // c is for cookie\n" - " // f is for false\n" - "\tfunction f(integer size) ; endfunction\n" - " // t is for true\n" - "task t();endtask\n" - " // class is about to end\n" - "endclass", - "class c; // c is for cookie\n" - " // f is for false\n" - " function f(integer size);\n" - " endfunction\n" - " // t is for true\n" - " task t();\n" - " endtask\n" - " // class is about to end\n" - "endclass\n"}, - - // interface class test cases - {"interface class Foo;\nendclass\n", - "interface class Foo;\n" - "endclass\n"}, - {"interface class Foo ; endclass\n", - "interface class Foo;\n" - "endclass\n"}, - {"interface class Foo extends Bar , Baz ;\nendclass\n", - "interface class Foo extends Bar, Baz;\n" - "endclass\n"}, - {"interface class Foo;\n pure virtual task foo ( ) ; \nendclass\n", - "interface class Foo;\n" - " pure virtual task foo();\n" - "endclass\n"}, - - // class property alignment test cases - {"class c;\n" - "int foo ;\n" - "byte bar;\n" - "endclass : c\n", - "class c;\n" - " int foo;\n" - " byte bar;\n" - "endclass : c\n"}, - {"class c;\n" - "int foo;\n" - "const bit b;\n" - "endclass : c\n", - "class c;\n" - " int foo;\n" - " const bit b;\n" - "endclass : c\n"}, - {"class c;\n" - "rand logic l;\n" - "int foo;\n" - "endclass : c\n", - "class c;\n" - " rand logic l;\n" - " int foo;\n" - "endclass : c\n"}, - {"class c;\n" - "rand logic l;\n" - "const static int foo;\n" // more qualifiers - "endclass : c\n", - "class c;\n" - " rand logic l;\n" - " const static int foo;\n" - "endclass : c\n"}, - {"class c;\n" - "static local int foo;\n" - "const bit b;\n" - "endclass : c\n", - "class c;\n" - " static local int foo;\n" - " const bit b;\n" - "endclass : c\n"}, - {// example with queue - "class c;\n" - "int foo [$] ;\n" - "int foo_bar ;\n" - "endclass : c\n", - "class c;\n" - " int foo [$];\n" - " int foo_bar;\n" - "endclass : c\n"}, - {// subcolumns - "class cc;\n" - "rand bit [A-1:0] foo;\n" - "rand bit [A-1:0][2] bar;\n" - "int foobar[X+1:Y];\n" - "int baz[42];\n" - "rand bit qux[Z];\n" - "rand bit [1:0] quux[3:0];\n" - "rand bit [A:BB][42] quuz[7];\n" - "endclass\n", - "class cc;\n" - " rand bit [A-1: 0] foo;\n" - " rand bit [A-1: 0][ 2] bar;\n" - " int foobar[X+1:Y];\n" - " int baz [ 42];\n" - " rand bit qux [ Z];\n" - " rand bit [ 1: 0] quux [ 3:0];\n" - " rand bit [ A:BB][42] quuz [ 7];\n" - "endclass\n"}, - {"class cc;\n" - "int qux[2];\n" - "int quux[SIZE-1+SHIFT:SHIFT];\n" - "int quuz[SOME_CONSTANT];\n" - "endclass\n", - "class cc;\n" - " int qux [ 2];\n" - " int quux[SIZE-1+SHIFT:SHIFT];\n" - " int quuz[ SOME_CONSTANT];\n" - "endclass\n"}, - {// aligns over comments (ignored) - "class c;\n" - "// foo is...\n" - "int foo;\n" - "// b is...\n" - "const bit b;\n" - " // llama is...\n" - "logic llama;\n" - "endclass : c\n", - "class c;\n" - " // foo is...\n" - " int foo;\n" - " // b is...\n" - " const bit b;\n" - " // llama is...\n" - " logic llama;\n" - "endclass : c\n"}, - {// aligns over comments (ignored), even with blank lines - "class c;\n" - "// foo is...\n" - "int foo;\n" - "\n" - "// b is...\n" - "const bit b;\n" - "\n" - " // llama is...\n" - "logic llama;\n" - "endclass : c\n", - "class c;\n" - " // foo is...\n" - " int foo;\n" - "\n" - " // b is...\n" - " const bit b;\n" - "\n" - " // llama is...\n" - " logic llama;\n" - "endclass : c\n"}, - {"class c;\n" - "rand logic l;\n" - "int [1:0] foo;\n" - "endclass : c\n", - "class c;\n" - " rand logic l;\n" - " int [1:0] foo;\n" - "endclass : c\n"}, - {// non-data-declarations break up groups - "class c;\n" - "rand logic l;\n" - "int foo;\n" - "`uvm_bar_foo()\n" - "logic k;\n" - "rand int bar;\n" - "endclass : c\n", - "class c;\n" - " rand logic l;\n" - " int foo;\n" - " `uvm_bar_foo()\n" // separates alignment groups above/below - " logic k;\n" - " rand int bar;\n" - "endclass : c\n"}, - {// non-data-declarations break up groups - "class c;\n" - "logic k;\n" - "rand int bar;\n" - "function void f();\n" - "endfunction\n" - "rand logic l;\n" - "int foo;\n" - "endclass : c\n", - "class c;\n" - " logic k;\n" - " rand int bar;\n" - " function void f();\n" // function declaration breaks groups - " endfunction\n" - " rand logic l;\n" - " int foo;\n" - "endclass : c\n"}, - {// align single-value initializers at the '=' - "class c;\n" - "const logic foo=0;\n" - "const bit b=1;\n" - "endclass : c\n", - "class c;\n" - " const logic foo = 0;\n" - " const bit b = 1;\n" - "endclass : c\n"}, - {// align single-value initializers at the '=', over non-initialized - "class c;\n" - "const logic foo=0;\n" - "rand int iidrv;\n" - "const bit b=1;\n" - "endclass : c\n", - "class c;\n" - " const logic foo = 0;\n" - " rand int iidrv;\n" // no initializer, but align across this - " const bit b = 1;\n" - "endclass : c\n"}, - - // constraint test cases - { - "class foo; constraint c1_c{ } endclass", - "class foo;\n" - " constraint c1_c {}\n" - "endclass\n", - }, - { - "class foo; constraint c1_c{ } constraint c2_c{ } endclass", - "class foo;\n" - " constraint c1_c {}\n" - " constraint c2_c {}\n" - "endclass\n", - }, - { - "class foo; constraint c1_c{soft z==y;unique{baz};}endclass", - "class foo;\n" - " constraint c1_c {\n" - " soft z == y;\n" - " unique {baz};\n" - " }\n" - "endclass\n", - }, - { - "class foo; constraint c1_c{ //comment1\n" - "//comment2\n" - "//comment3\n" - "} endclass", - "class foo;\n" - " constraint c1_c { //comment1\n" - " //comment2\n" - " //comment3\n" - " }\n" - "endclass\n", - }, - - {"class foo;constraint c { " - "timer_enable dist { [ 8'h0 : 8'hfe ] :/ 90 , 8'hff :/ 10 }; " - "} endclass\n", - "class foo;\n" - " constraint c {\n" - " timer_enable dist {\n" - " [8'h0 : 8'hfe] :/ 90,\n" - " 8'hff :/ 10\n" // aligned - " };\n" - " }\n" - "endclass\n"}, - - { - "class Foo; constraint if_c { if (z) { soft x == y; } } endclass\n", - "class Foo;\n" - " constraint if_c {\n" - " if (z) {\n" - " soft x == y;\n" - " }\n" - " }\n" - "endclass\n", - }, - { - "class Foo; constraint if_c { if (z) {\n" - "//comment-a\n" - "soft x == y;\n" - "//comment-b\n" - "} } endclass\n", - "class Foo;\n" - " constraint if_c {\n" - " if (z) {\n" - " //comment-a\n" // properly indented - " soft x == y;\n" - " //comment-b\n" // properly indented - " }\n" - " }\n" - "endclass\n", - }, - { - "class c; " - "constraint c_has_config_error {" - "if (yyy) {zzzz == 1;} else {yyyyyyy == 0;}} " - "endclass", - "class c;\n" - " constraint c_has_config_error {\n" - " if (yyy) {\n" - " zzzz == 1;\n" - " } else {\n" - " yyyyyyy == 0;\n" - " }\n" - " }\n" - "endclass\n", - }, - // distributions: colon alignment - {"class c;\n" - "constraint co {\n" - "d dist {\n" - "[1:2]:/2,\n" - "[11:33]:/22,\n" - "[111:444]:/8,\n" - "[1:42]:/10,\n" - "[11:12]:/3\n" - "};\n" - "}\n" - "endclass\n", - "class c;\n" - " constraint co {\n" - " d dist {\n" - " [ 1 : 2] :/ 2,\n" - " [ 11 : 33] :/ 22,\n" - " [111 : 444] :/ 8,\n" - " [ 1 : 42] :/ 10,\n" - " [ 11 : 12] :/ 3\n" - " };\n" - " }\n" - "endclass\n"}, - // distributions: subcolumns - {"class foo;\n" - "constraint bar {\n" - "baz dist {\n" - "[1:2]:/2,\n" - "QUX[3:0]:/10,\n" - "[11:33]:/22,\n" - "ID_LONGER_THAN_RANGES:/3,\n" - "[111:QUUZ[Z]]:/8,\n" - "[X[4:0]:Y[8:Z-2]]:/8\n" - "};\n" - "}\n" - "endclass\n", - "class foo;\n" - " constraint bar {\n" - " baz dist {\n" - " [ 1 : 2] :/ 2,\n" - " QUX[3:0] :/ 10,\n" - " [ 11 : 33] :/ 22,\n" - " ID_LONGER_THAN_RANGES :/ 3,\n" - " [ 111 : QUUZ[Z]] :/ 8,\n" - " [X[4:0] : Y[8:Z-2]] :/ 8\n" - " };\n" - " }\n" - "endclass\n"}, - // class with empty parameter list - {"class foo #(); endclass", - "class foo #();\n" - "endclass\n"}, - // class with empty parameter list, with comment - {"class foo #( \n" - "// comment\n" - "); endclass", - "class foo #(\n" - " // comment\n" - ");\n" - "endclass\n"}, - // class with empty parameter list, extends - {"class foo #()extends bar ; endclass", - "class foo #() extends bar;\n" - "endclass\n"}, - // class extends from type with named parameters - {"class foo extends bar #(.N(N), .M(M)); endclass", - "class foo extends bar #(\n" - " .N(N),\n" - " .M(M)\n" - ");\n" - "endclass\n"}, - - // class with one parameter list - {"class foo #(type a = b); endclass", - "class foo #(\n" - " type a = b\n" - ");\n" - "endclass\n"}, - - // class with multiple paramter list - {"class foo #(type a = b, type c = d, type e = f); endclass", - "class foo #(\n" - " type a = b,\n" - " type c = d,\n" - " type e = f\n" - ");\n" - "endclass\n"}, - - // class with data members - {"class i_love_data ;const\ninteger sizer\t;endclass", - "class i_love_data;\n" - " const integer sizer;\n" - "endclass\n"}, - {"class i_love_data ;const\ninteger sizer=3\t;endclass", - "class i_love_data;\n" - " const integer sizer = 3;\n" - "endclass\n"}, - {"class i_love_data ;protected\nint count \t;endclass", - "class i_love_data;\n" - " protected int count;\n" - "endclass\n"}, - {"class i_love_data ;\t\nint counter\n ;int countess \t;endclass", - "class i_love_data;\n" - " int counter;\n" - " int countess;\n" - "endclass\n"}, - {"class i_love_params ;foo#( . bar) baz\t;endclass", - "class i_love_params;\n" - " foo #(.bar) baz;\n" - "endclass\n"}, - {"class i_love_params ;foo#( . bar ( bah )) baz\t;endclass", - "class i_love_params;\n" - " foo #(.bar(bah)) baz;\n" - "endclass\n"}, - {"class i_love_params ;foo#( . bar ( bah\n)," - ".\ncat( dog) ) baz\t;endclass", - "class i_love_params;\n" - " foo #(\n" - " .bar(bah),\n" - " .cat(dog)\n" - " ) baz;\n" - "endclass\n"}, - {"class i_love_params ;foo#( . bar) baz1,baz2\t;endclass", - "class i_love_params;\n" - " foo #(.bar) baz1, baz2;\n" - "endclass\n"}, - {"class i_love_params ;foo#( . bar) baz\t;baz#(.foo)bar;endclass", - "class i_love_params;\n" - " foo #(.bar) baz;\n" - " baz #(.foo) bar;\n" - "endclass\n"}, - {"class i_love_params // comment\n" - ";\n" - "foo#(\n" - ".foobar(quuuuux) // comment\n" - ", .cat(dog)\n" - ") baz // comment\n" - ";endclass\n", - "class i_love_params // comment\n" - ";\n" - " foo #(\n" - " .foobar(quuuuux) // comment\n" - " , .cat (dog)\n" - " ) baz // comment\n" - " ;\n" - "endclass\n"}, - - // typedef test cases - {"typedef enum logic\t{ A=0, B=1 }foo_t;", - "typedef enum logic {\n" - " A = 0,\n" - " B = 1\n" - "} foo_t;\n"}, - {"typedef enum uint8_t\t{ kA=8'b0, kB=8'b1 }foo_t;", - "typedef enum uint8_t {\n" // uint8_t is user-defined - " kA = 8'b0,\n" - " kB = 8'b1\n" - "} foo_t;\n"}, - {// With comments on same line as enum value - "typedef enum logic\t{ A=0, // foo\n" - "B,// bar\n" - "`ifndef DO_PANIC\n" - "C=42,// answer\n" - "`endif\n" - "D=3 // baz\n" - "}foo_t;", - "typedef enum logic {\n" - " A = 0, // foo\n" - " B, // bar\n" - "`ifndef DO_PANIC\n" - " C = 42, // answer\n" - "`endif\n" - " D = 3 // baz\n" - "} foo_t;\n"}, - {// with scalar dimensions - "typedef enum logic[2]\t{ A=0, B=1 }foo_t;", - "typedef enum logic [2] {\n" - " A = 0,\n" - " B = 1\n" - "} foo_t;\n"}, - {// with range dimensions - "typedef enum logic[1:0]\t{ A=0, B=1 }foo_t;", - "typedef enum logic [1:0] {\n" - " A = 0,\n" - " B = 1\n" - "} foo_t;\n"}, - {"typedef foo_pkg::baz_t#(.L(L), .W(W)) bar_t;\n", - "typedef foo_pkg::baz_t#(\n" - " .L(L),\n" - " .W(W)\n" - ") bar_t;\n"}, - // unqualified parameterized type keeps a space before '#' - {"typedef dv_base_env_cov #(.CFG_T(tl_agent_env_cfg)) tl_agent_env_cov;\n", - "typedef dv_base_env_cov #(\n" - " .CFG_T(tl_agent_env_cfg)\n" - ") tl_agent_env_cov;\n"}, - // ... and is inserted when absent - {"typedef dv_base_env_cov#(.CFG_T(tl_agent_env_cfg)) tl_agent_env_cov;\n", - "typedef dv_base_env_cov #(\n" - " .CFG_T(tl_agent_env_cfg)\n" - ") tl_agent_env_cov;\n"}, - // single short parameter stays on one line - {"typedef my_class #(.P(P)) my_class_t;\n", - "typedef my_class #(.P(P)) my_class_t;\n"}, - - // package test cases - {"package fedex;localparam int www=3 ;endpackage : fedex\n", - "package fedex;\n" - " localparam int www = 3;\n" - "endpackage : fedex\n"}, - {"package typey ;" - "typedef enum int{ A=0, B=1 }foo_t;" - "typedef enum{ C=0, D=1 }bar_t;" - "endpackage:typey\n", - "package typey;\n" - " typedef enum int {\n" - " A = 0,\n" - " B = 1\n" - " } foo_t;\n" - " typedef enum {\n" - " C = 0,\n" - " D = 1\n" - " } bar_t;\n" - "endpackage : typey\n"}, - {// net type declarations - "package foo_pkg;" - "nettype shortreal\t\tfoo ;" - "nettype\nbar[1:0 ] baz with\tquux ;" - "endpackage", - "package foo_pkg;\n" - " nettype shortreal foo;\n" - " nettype bar [1:0] baz with quux;\n" - "endpackage\n"}, - {"package foo_pkg; \n" - "// function description.......\n" - "function automatic void bar();" - "endfunction " - "endpackage\n", - "package foo_pkg;\n" - " // function description.......\n" - " function automatic void bar();\n" - " endfunction\n" - "endpackage\n"}, - {"package foo_pkg; \n" - "// function description.......\n" - "function void bar(string name=\"x\" ) ;" - "endfunction " - "endpackage\n", - "package foo_pkg;\n" - " // function description.......\n" - " function void bar(string name = \"x\");\n" - " endfunction\n" - "endpackage\n"}, - {" package foo_pkg; \n" - "// class description.............\n" - "class classy;" - "endclass " - "endpackage\n", - "package foo_pkg;\n" - " // class description.............\n" - " class classy;\n" - " endclass\n" - "endpackage\n"}, - {"package\tfoo_pkg; \n" - "// class description.............\n" - "class classy; \n" - "// function description.......\n" - "function\nautomatic void bar( );" - "endfunction " - "endclass\t" - "endpackage\n", - "package foo_pkg;\n" - " // class description.............\n" - " class classy;\n" - " // function description.......\n" - " function automatic void bar();\n" - " endfunction\n" - " endclass\n" - "endpackage\n"}, - {"package fedex;\n" - " import \"asdf\" context function void bar(\n" - " input bit [2:1] aaaa, // EOL COMMENT\n" - " // another\n" - " input bit foo\n" - " );\n" - "endpackage\n", - "package fedex;\n" - " import \"asdf\" context\n" - " function void bar(\n" - " input\n bit [2:1] aaaa, // EOL COMMENT\n" - " // another\n" - " input bit foo\n" - " );\n" - "endpackage\n"}, - - // function test cases - {"function f ;endfunction", "function f;\nendfunction\n"}, - {"function f ;endfunction: f", "function f;\nendfunction : f\n"}, - {"function f ( );endfunction", "function f();\nendfunction\n"}, - {"function f (input bit x);endfunction", - "function f(input bit x);\nendfunction\n"}, - {"function f (input bit x,logic y );endfunction", - "function f(input bit x, logic y);\nendfunction\n"}, - {"function f;\n// statement comment\nendfunction\n", - "function f;\n" - " // statement comment\n" // indented - "endfunction\n"}, - {"function f();\n// statement comment\nendfunction\n", - "function f();\n" - " // statement comment\n" // indented - "endfunction\n"}, - {"function f(input int x);\n" - "// statement comment\n" - "f=x;\n" - "// statement comment\n" - "endfunction\n", - "function f(input int x);\n" - " // statement comment\n" // indented - " f = x;\n" - " // statement comment\n" // indented - "endfunction\n"}, - {// line breaks around assignments - "function f;a=b;c+=d;endfunction", - "function f;\n" - " a = b;\n" - " c += d;\n" - "endfunction\n"}, - {"function f;a&=b;c=d;endfunction", - "function f;\n" - " a &= b;\n" - " c = d;\n" - "endfunction\n"}, - {"function f;a<<=b;c=b;d>>>=b;endfunction", - "function f;\n" - " a <<= b;\n" - " c = b;\n" - " d >>>= b;\n" - "endfunction\n"}, - {// port declaration exceeds line length limit - "function f (loooong_type if_it_fits_I_sits);endfunction", - "function f(\n" - " loooong_type if_it_fits_I_sits);\n" - "endfunction\n"}, - {"function\nvoid\tspace;a=( b+c )\n;endfunction :space\n", - "function void space;\n" - " a = (b + c);\n" - "endfunction : space\n"}, - {"function\nvoid\twarranty;return to_sender\n;endfunction :warranty\n", - "function void warranty;\n" - " return to_sender;\n" - "endfunction : warranty\n"}, - {// if statement that fits on one line - "function if_i_fits_i_sits;" - "if(x)y=x;" - "endfunction", - "function if_i_fits_i_sits;\n" - " if (x) y = x;\n" - "endfunction\n"}, - {// for loop - "function\nvoid\twarranty;for(j=0; j<k; --k)begin " - "++j\n;end endfunction :warranty\n", - "function void warranty;\n" - " for (j = 0; j < k; --k) begin\n" - " ++j;\n" - " end\n" - "endfunction : warranty\n"}, - {// for loop that needs wrapping - "function\nvoid\twarranty;for(jjjjj=0; jjjjj<kkkkk; --kkkkk)begin " - "++j\n;end endfunction :warranty\n", - "function void warranty;\n" - " for (\n" - " jjjjj = 0; jjjjj < kkkkk; --kkkkk\n" - " ) begin\n" - " ++j;\n" - " end\n" - "endfunction : warranty\n"}, - {// for loop that needs more wrapping - "function\nvoid\twarranty;" - "for(jjjjjjjj=0; jjjjjjjj<kkkkkkkk; --kkkkkkkk)begin " - "++j\n;end endfunction :warranty\n", - "function void warranty;\n" - " for (\n" - " jjjjjjjj = 0;\n" - " jjjjjjjj < kkkkkkkk;\n" - " --kkkkkkkk\n" - " ) begin\n" - " ++j;\n" - " end\n" - "endfunction : warranty\n"}, - {// for loop that fits on one line - "function loop_fits;" - "for(x=0;x<N;++x) y=x;" - "endfunction", - "function loop_fits;\n" - " for (x = 0; x < N; ++x) y = x;\n" - "endfunction\n"}, - {// for loop that would fit on one line, but is force-split with //comment - "function loop_fits;" - "for(x=0;x<N;++x) //\n y=x;" - "endfunction", - "function loop_fits;\n" - " for (x = 0; x < N; ++x) //\n" - " y = x;\n" - "endfunction\n"}, - {// for loop with function call in initializer - "function void looper(); " - "for (int i=f(n); i>=0; i -- ) begin end " - "endfunction", - "function void looper();\n" - " for (int i = f(n); i >= 0; i--) begin\n" - " end\n" - "endfunction\n"}, - {// for loop with function call in condition - "function void looper(); " - "for (int i=0; i<f(m); i -- ) begin end " - "endfunction", - "function void looper();\n" - " for (int i = 0; i < f(m); i--) begin\n" - " end\n" - "endfunction\n"}, - {// forever loop - "function\nvoid\tforevah;forever begin " - "++k\n;end endfunction\n", - "function void forevah;\n" - " forever begin\n" - " ++k;\n" - " end\n" - "endfunction\n"}, - {// forever loop - "function\nvoid\tforevah;forever " - "++k\n;endfunction\n", - "function void forevah;\n" - " forever ++k;\n" - "endfunction\n"}, - {// forever loop, forced break - "function\nvoid\tforevah;forever //\n" - "++k\n;endfunction\n", - "function void forevah;\n" - " forever //\n" - " ++k;\n" - "endfunction\n"}, - {// repeat loop - "function\nvoid\tpete;repeat(3) begin " - "++k\n;end endfunction\n", - "function void pete;\n" - " repeat (3) begin\n" - " ++k;\n" - " end\n" - "endfunction\n"}, - {// repeat loop - "function\nvoid\tpete;repeat(3) " - "++k\n;endfunction\n", - "function void pete;\n" - " repeat (3)++k;\n" // TODO(fangism): space before ++ - "endfunction\n"}, - {// repeat loop, forced break - "function\nvoid\tpete;repeat(3)//\n" - "++k\n;endfunction\n", - "function void pete;\n" - " repeat (3) //\n" - " ++k;\n" - "endfunction\n"}, - {// while loop - "function\nvoid\twily;while( coyote ) begin " - "++super_genius\n;end endfunction\n", - "function void wily;\n" - " while (coyote) begin\n" - " ++super_genius;\n" - " end\n" - "endfunction\n"}, - {// while loop - "function\nvoid\twily;while( coyote ) " - "++ super_genius\n; endfunction\n", - "function void wily;\n" - " while (coyote)++super_genius;\n" // TODO(fangism): space before ++ - "endfunction\n"}, - {// while loop, forced break - "function\nvoid\twily;while( coyote ) //\n " - "++ super_genius\n; endfunction\n", - "function void wily;\n" - " while (coyote) //\n" - " ++super_genius;\n" - "endfunction\n"}, - {// do-while loop - "function\nvoid\tdonot;do begin " - "++s\n;end while( z);endfunction\n", - "function void donot;\n" - " do begin\n" - " ++s;\n" - " end while (z);\n" - "endfunction\n"}, - {// do-while loop, single statement - "function\nvoid\tdonot;do " - "++s\n; while( z);endfunction\n", - "function void donot;\n" - " do ++s; while (z);\n" - "endfunction\n"}, - {// do-while loop, single statement, forced break - "function\nvoid\tdonot;do " - "++s\n;//\n while( z);endfunction\n", - "function void donot;\n" - " do\n" - " ++s; //\n" - " while (z);\n" - "endfunction\n"}, - {// foreach loop - "function\nvoid\tforeacher;foreach( m [n] ) begin " - "++m\n;end endfunction\n", - "function void foreacher;\n" - " foreach (m[n]) begin\n" - " ++m;\n" - " end\n" - "endfunction\n"}, - {// spaces in condition expression - "function f; return {a}? {b} :{ c };endfunction", - "function f;\n" - " return {a} ? {b} : {c};\n" - "endfunction\n"}, - {"task t;endtask", - "task t;\n" - "endtask\n"}, - {"task t ( );endtask", - "task t();\n" - "endtask\n"}, - {"task t (input bit drill ) ;endtask", - "task t(input bit drill);\n" - "endtask\n"}, - {"task t; ## 100 ;endtask", - "task t;\n" - " ##100;\n" - "endtask\n"}, - {"task t; ## (1+1) ;endtask", // delay expression - "task t;\n" - " ##(1 + 1);\n" - "endtask\n"}, - {"task t; ## delay_value ;endtask", - "task t;\n" - " ##delay_value;\n" - "endtask\n"}, - {"task t; ## `DELAY_VALUE ;endtask", - "task t;\n" - " ##`DELAY_VALUE;\n" - "endtask\n"}, - {"task t;\n" - "`uvm_error( foo,bar);\n" - "endtask\n", - "task t;\n" - " `uvm_error(foo, bar);\n" - "endtask\n"}, - {"task t;\n" - "`uvm_error(foo,bar)\n" - ";\n" // null statement - "endtask\n", - "task t;\n" - " `uvm_error(foo, bar)\n" - " ;\n" - "endtask\n"}, - {"task t;\n" - "if(expr)begin\t\n" - "`uvm_error(foo,bar);\n" - "end\n" - "endtask\n", - "task t;\n" - " if (expr) begin\n" - " `uvm_error(foo, bar);\n" - " end\n" - "endtask\n"}, - {"task\nrabbit;$kill(the,\nrabbit)\n;endtask: rabbit\n", - "task rabbit;\n" - " $kill(the, rabbit);\n" - "endtask : rabbit\n"}, - {"function int foo( );if( a )a+=1 ; endfunction", - "function int foo();\n" - " if (a) a += 1;\n" - "endfunction\n"}, - {"function void foo( );foo=`MACRO(b,c) ; endfunction", - "function void foo();\n" - " foo = `MACRO(b, c);\n" - "endfunction\n"}, - {"module foo;if \t (bar)begin assign a=1; end endmodule", - "module foo;\n" - " if (bar) begin\n" - " assign a = 1;\n" - " end\n" - "endmodule\n"}, - {"module proc_cont_assigner;\n" - "always begin\n" - "assign x1 = y1;\n" - "deassign x2 ;\n" - "force x3=y3;\n" - "release x4 ;\n" - "end\n" - "endmodule\n", - "module proc_cont_assigner;\n" - " always begin\n" - " assign x1 = y1;\n" - " deassign x2;\n" - " force x3 = y3;\n" - " release x4;\n" - " end\n" - "endmodule\n"}, - {"module g_test( );\n" - "\tinitial begin:main_test \t" - "for(int i=0;i<k;i++)begin " - "case(i )\n" - " 6'd0 :release in[0]; \n" - " endcase " - " \t\tend \t" - "\t end:main_test\n" - "endmodule:g_test\n", - "module g_test ();\n" - " initial begin : main_test\n" - " for (int i = 0; i < k; i++) begin\n" - " case (i)\n" - " 6'd0: release in[0];\n" - " endcase\n" - " end\n" - " end : main_test\n" - "endmodule : g_test\n"}, - {// conditional generate (case) - "module mc; case(s)a : bb c ; d : ee f; endcase endmodule", - "module mc;\n" - " case (s)\n" - " a: bb c;\n" - " d: ee f;\n" - " endcase\n" - "endmodule\n"}, - {// conditional generate (case), with comments - "module mc; case(s)\n//comment a\na:bb c;\n//comment b\n endcase " - "endmodule", - "module mc;\n" - " case (s)\n" - " //comment a\n" // indented to case-item level - " a: bb c;\n" - " //comment b\n" // indented to case-item level - " endcase\n" - "endmodule\n"}, - - {// "default:", not "default :" - "function f; case (x) default: x=y; endcase endfunction\n", - "function f;\n" - " case (x)\n" - " default: x = y;\n" - " endcase\n" - "endfunction\n"}, - {// default with null statement: "default: ;", not "default :;" - "function f; case (x) default :; endcase endfunction\n", - "function f;\n" - " case (x)\n" - " default: ;\n" - " endcase\n" - "endfunction\n"}, - {// case statement - "function f; case (x) State0 : a=b; State1 : begin a=b; end " - "endcase endfunction\n", - "function f;\n" - " case (x)\n" - " State0: a = b;\n" - " State1: begin\n" - " a = b;\n" - " end\n" - " endcase\n" - "endfunction\n"}, - {// case statement, interleaved with comments - "function f; case (x) \n//c1\nState0 : a=b;//c2\n//c3\n State1 : " - "a=b;//c4\n//c5\n " - "endcase endfunction\n", - "function f;\n" - " case (x)\n" - " //c1\n" - " State0: a = b; //c2\n" - " //c3\n" - " State1: a = b; //c4\n" - " //c5\n" - " endcase\n" - "endfunction\n"}, - {// case inside statement, comments - "function f; case (x)inside \n//comment\n" - "[0:1]:x=y; \n" - " //comment\n" - "endcase endfunction\n", - "function f;\n" - " case (x) inside\n" - " //comment\n" - " [0 : 1]: x = y;\n" - " //comment\n" - " endcase\n" - "endfunction\n"}, - {// case inside statement - "function f; case (x)inside k1 : return b; k2 : begin return b; end " - "endcase endfunction\n", - "function f;\n" - " case (x) inside\n" - " k1: return b;\n" - " k2: begin\n" - " return b;\n" - " end\n" - " endcase\n" - "endfunction\n"}, - {// case inside statement, with ranges - "function f; case (x) inside[a:b] : return b; [c:d] : return b; " - "default :return z;" - "endcase endfunction\n", - "function f;\n" - " case (x) inside\n" - " [a : b]: return b;\n" - " [c : d]: return b;\n" - " default: return z;\n" - " endcase\n" - "endfunction\n"}, - {// case pattern statement - "function f;" - "case (y) matches " - ".foo : return 0;" - ".*\t: return 1;" - "endcase " - "case (z) matches " - ".foo\t\t: return 0;" - ".* : return 1;" - "endcase " - "endfunction", - "function f;\n" - " case (y) matches\n" - " .foo: return 0;\n" - " .*: return 1;\n" - " endcase\n" - " case (z) matches\n" - " .foo: return 0;\n" - " .*: return 1;\n" - " endcase\n" - "endfunction\n"}, - {// keep short case items on one line - "function f; case (x)k1 : if( b )break; default :return 2;" - "endcase endfunction\n", - "function f;\n" - " case (x)\n" - " k1: if (b) break;\n" // aligned - " default: return 2;\n" - " endcase\n" - "endfunction\n"}, - {// keep short default items on one line - "function f; case (x)k1 :break; default :if( c )return 2;" - "endcase endfunction\n", - "function f;\n" - " case (x)\n" - " k1: break;\n" // aligned - " default: if (c) return 2;\n" - " endcase\n" - "endfunction\n"}, - {// keep short case inside items on one line - "function f; case (x)inside k1 : if( b )return c; k2 : return a;" - "endcase endfunction\n", - "function f;\n" - " case (x) inside\n" - " k1: if (b) return c;\n" - " k2: return a;\n" - " endcase\n" - "endfunction\n"}, - {// keep short case pattern items on one line - "function f;" - "case (y) matches " - ".foo :if( n )return 0;" - ".*\t: return 1;" - "endcase " - "endfunction", - "function f;\n" - " case (y) matches\n" - " .foo: if (n) return 0;\n" - " .*: return 1;\n" - " endcase\n" - "endfunction\n"}, - {// randcase - "function f; randcase k1 : return c; k2 : return a;" - "endcase endfunction\n", - "function f;\n" - " randcase\n" - " k1: return c;\n" - " k2: return a;\n" - " endcase\n" - "endfunction\n"}, - - // This tests checks for not breaking around hierarchy operators. - {"function\nvoid\twarranty;" - "foo.bar = fancyfunction(aaaaaaaa.bbbbbbb," - " ccccccccc.ddddddddd) ;" - "endfunction :warranty\n", - "function void warranty;\n" - " foo.bar = fancyfunction(\n" - " aaaaaaaa.bbbbbbb,\n" - " ccccccccc.ddddddddd\n" - " );\n" - "endfunction : warranty\n"}, - - // Group of tests testing partitioning of arguments inside function calls - {// function with function call inside if statement header - "function foo;if(aa(bb,cc));endfunction\n", - "function foo;\n" - " if (aa(bb, cc));\n" - "endfunction\n"}, - {// function with function call inside if statement header and with - // begin-end block - "function foo;if (aa(bb,cc,dd,ee))begin end endfunction\n", - "function foo;\n" - " if (aa(bb, cc, dd, ee)) begin\n" - " end\n" - "endfunction\n"}, - {// function with kMethodCallExtension inside if statement header and with - // begin-end block - "function foo;if (aa.bb(cc,dd,ee))begin end endfunction\n", - "function foo;\n" - " if (aa.bb(cc, dd, ee)) begin\n" - " end\n" - "endfunction\n"}, - {// nested kMethodCallExtension calls - one level - "function foo;aa.bb(cc.dd(a1), ee.ff(a2));endfunction\n", - "function foo;\n" - " aa.bb(cc.dd(a1), ee.ff(a2));\n" - "endfunction\n"}, - {// nested kMethodCallExtension calls - two level - "function foo;aa.bb(cc.dd(a1.b1(a2), b1), ee.ff(c1, d1));endfunction\n", - "function foo;\n" - " aa.bb(cc.dd(a1.b1(a2), b1), ee.ff(\n" - " c1, d1));\n" - "endfunction\n"}, - - {// simple initial statement with function call - "module m;initial aa(bb,cc,dd,ee);endmodule\n", - "module m;\n" - " initial aa(bb, cc, dd, ee);\n" - "endmodule\n"}, - {// expressions and function calls inside if-statement headers - "module m;initial begin if(aa(bb)==cc(dd))a=b;if (xx()) b = a;end " - "endmodule\n", - "module m;\n" - " initial begin\n" - " if (aa(bb) == cc(dd)) a = b;\n" - " if (xx()) b = a;\n" - " end\n" - "endmodule\n"}, - {// fuction with two arguments inside if-statement headers - "module\nm;initial\nbegin\nif(aa(bb,cc))x=y;end\nendmodule\n", - "module m;\n" - " initial begin\n" - " if (aa(bb, cc)) x = y;\n" - " end\n" - "endmodule\n"}, - {// kMethodCallExtension inside if-statement headers - "module m;initial begin if (aa.bb(cc)) x = y;end endmodule", - "module m;\n" - " initial begin\n" - " if (aa.bb(cc)) x = y;\n" - " end\n" - "endmodule\n"}, - {// initial statement with object method call - "module m; initial a.b(a,b,c); endmodule\n", - "module m;\n" - " initial a.b(a, b, c);\n" - "endmodule\n"}, - {// initial statement with method call on indexed object - "module m; initial a[i].b(a,b,c); endmodule\n", - "module m;\n" - " initial a[i].b(a, b, c);\n" - "endmodule\n"}, - {// initial statement with method call on function returned object - "module m; initial a(d,e,f).b(a,b,c); endmodule\n", - "module m;\n" - " initial a(d, e, f).b(a, b, c);\n" - "endmodule\n"}, - {// initial statement with indexed access to function returned object - "module m; initial a(a,b,c)[i]; endmodule\n", - "module m;\n" - " initial a(a, b, c) [i];\n" - "endmodule\n"}, - {// method call with no arguments on an object - "module m; initial foo.bar();endmodule\n", - "module m;\n" - " initial foo.bar();\n" - "endmodule\n"}, - {// method call with one argument on an object - "module m; initial foo.bar(aa);endmodule\n", - "module m;\n" - " initial foo.bar(aa);\n" - "endmodule\n"}, - {// method call with two arguments on an object - "module m; initial foo.bar(aa,bb);endmodule\n", - "module m;\n" - " initial foo.bar(aa, bb);\n" - "endmodule\n"}, - {// method call with three arguments on an object - "module m; initial foo.bar(aa,bb,cc);endmodule\n", - "module m;\n" - " initial foo.bar(aa, bb, cc);\n" - "endmodule\n"}, - - { - // This tests for if-statements with null statements - "function foo;" - "if (zz) ; " - "if (yy) ; " - "endfunction", - "function foo;\n" - " if (zz);\n" - " if (yy);\n" - "endfunction\n", - }, - - { - // This tests for if-statements starting on their own line. - "function foo;" - "if (zz) begin " - "return 0;" - "end " - "if (yy) begin " - "return 1;" - "end " - "endfunction", - "function foo;\n" - " if (zz) begin\n" - " return 0;\n" - " end\n" - " if (yy) begin\n" - " return 1;\n" - " end\n" - "endfunction\n", - }, - - { - // This tests for if-statements with single statement bodies - "function foo;" - "if (zz) return 0;" - "if (yy) return 1;" - "endfunction", - "function foo;\n" - " if (zz) return 0;\n" - " if (yy) return 1;\n" - "endfunction\n", - }, - - { - // This tests for if-statement mixed with plain statements - "function foo;" - "a=b;" - "if (zz) return 0;" - "c=d;" - "endfunction", - "function foo;\n" - " a = b;\n" - " if (zz) return 0;\n" - " c = d;\n" - "endfunction\n", - }, - - { - // This tests for if-statement with forced break mixed with others - "function foo;" - "a=b;" - "if (zz)//\n return 0;" - "c=d;" - "endfunction", - "function foo;\n" - " a = b;\n" - " if (zz) //\n" - " return 0;\n" - " c = d;\n" - "endfunction\n", - }, - { - "function t;" - "if (r == t)" - "a.b(c);" - "endfunction", - "function t;\n" - " if (r == t) a.b(c);\n" - "endfunction\n", - }, - - {// This tests for for-statement with forced break mixed with others - "function f;" - "x=y;" - "for (int i=0; i<S*IPS; i++) #1ps a += $urandom();" - "return 2;" - "endfunction", - "function f;\n" - " x = y;\n" - " for (int i = 0; i < S * IPS; i++)\n" // doesn't fit, so indents - " #1ps a += $urandom();\n" - " return 2;\n" - "endfunction\n"}, - - { - // This tests for-statements with null statements - "function foo;" - "for(;;) ;\t" - "for(;;) ;\t" - "endfunction", - "function foo;\n" - " for (;;);\n" - " for (;;);\n" - "endfunction\n", - }, - - { - // This tests for if-else-statements with null statements - "function foo;" - "if (zz) ; else ;" - "if (yy) ; else ;" - "endfunction", - "function foo;\n" - " if (zz);\n" - " else;\n" - " if (yy);\n" - " else;\n" - "endfunction\n", - }, - - { - // This tests for end-else-begin. - "function foo;" - "if (zz) begin " - "return 0;" - "end " - "else " - "begin " - "return 1;" - "end " - "endfunction", - "function foo;\n" - " if (zz) begin\n" - " return 0;\n" - " end else begin\n" - " return 1;\n" - " end\n" - "endfunction\n", - }, - { - // This tests for end-else-if - "function foo;" - "if (zz) begin " - "return 0;" - "end " - "else " - "if(yy)begin " - "return 1;" - "end " - "endfunction", - "function foo;\n" - " if (zz) begin\n" - " return 0;\n" - " end else if (yy) begin\n" - " return 1;\n" - " end\n" - "endfunction\n", - }, - { - // This tests labeled end-else-if - "function foo;" - "if (zz) begin : label1 " - "return 0;" - "end : label1 " - "else if (yy) begin : label2 " - "return 1;" - "end : label2 " - "endfunction", - "function foo;\n" - " if (zz) begin : label1\n" - " return 0;\n" - " end : label1\n" - " else if (yy) begin : label2\n" - " return 1;\n" - " end : label2\n" - "endfunction\n", - }, - { - // This tests labeled end-else-if-else - "function foo;" - "if (zz) begin : label1 " - "return 0;" - "end : label1 " - "else if (yy) begin : label2 " - "return 1;" - "end : label2 " - "else begin : label3 " - "return 2;" - "end : label3 " - "endfunction", - "function foo;\n" - " if (zz) begin : label1\n" - " return 0;\n" - " end : label1\n" - " else if (yy) begin : label2\n" - " return 1;\n" - " end : label2\n" - " else begin : label3\n" - " return 2;\n" - " end : label3\n" - "endfunction\n", - }, - - { - // randomize function - "function r ;" - "if ( ! randomize (bar )) begin end " - "if ( ! obj.randomize (bar )) begin end " - "endfunction", - "function r;\n" - " if (!randomize(bar)) begin\n" - " end\n" - " if (!obj.randomize(bar)) begin\n" - " end\n" - "endfunction\n", - }, - { - // randomize-with call, with comments - "function f;" - "s = std::randomize() with {\n" - "// comment1\n" - "a == e;\n" - "// comment2\n" - "};" - "endfunction\n", - "function f;\n" - " s = std::randomize() with {\n" - " // comment1\n" - " a == e;\n" - " // comment2\n" - " };\n" - "endfunction\n", - }, - { - // randomize-with call, with comments, one joined - "function f;" - "s = std::randomize() with {\n" - "// comment1\n" - "a == e;// comment2\n" - "};" - "endfunction\n", - "function f;\n" - " s = std::randomize() with {\n" - " // comment1\n" - " a == e; // comment2\n" - " };\n" - "endfunction\n", - }, - { - // randomize-with call, with comment, and conditional - "function f;" - "s = std::randomize() with {\n" - "// comment\n" - "a == e;" - "if (x) {" - "a;" - "}" - "};" - "endfunction\n", - "function f;\n" - " s = std::randomize() with {\n" - " // comment\n" - " a == e;\n" - " if (x) {a;}\n" // TODO(fangism): consider expanding - " };\n" - "endfunction\n", - }, - - // module declaration test cases - {" module foo ; endmodule\n", - "module foo;\n" - "endmodule\n"}, - {" module foo ( ) ; endmodule\n", - "module foo ();\n" - "endmodule\n"}, - {" module foo ( .x ( x) ); endmodule\n", - "module foo (\n" - " .x(x)\n" - ");\n" - "endmodule\n"}, - {" module foo ( .x ( x) \n,\n . y " - " ( \ny) ); endmodule\n", - "module foo (\n" - " .x(x),\n" - " .y(y)\n" - ");\n" - "endmodule\n"}, - - // module instantiation test cases - {" module foo ; bar bq();endmodule\n", - "module foo;\n" - " bar bq ();\n" // single instance - "endmodule\n"}, - {" module foo ; bar bq(), bq2( );endmodule\n", - "module foo;\n" - " bar bq (), bq2 ();\n" // multiple instances, still fitting on one line - "endmodule\n"}, - {"module foo; bar #(.N(N)) bq (.bus(bus));endmodule\n", - // instance parameter and port fits on line - "module foo;\n" - " bar #(.N(N)) bq (.bus(bus));\n" - "endmodule\n"}, - {"module foo; bar #(.N(N),.M(M)) bq ();endmodule\n", // two named params - "module foo;\n" - " bar #(\n" - " .N(N),\n" - " .M(M)\n" - " ) bq ();\n" - "endmodule\n"}, - {"module foo; bar #(//comment\n.N(N),.M(M)) bq ();endmodule\n", - "module foo;\n" - " bar #( //comment\n" // EOL comment before first param - " .N(N),\n" - " .M(M)\n" - " ) bq ();\n" - "endmodule\n"}, - {"module foo; bar #(.N(N),//comment\n.M(M)) bq ();endmodule\n", - "module foo;\n" - " bar #(\n" - " .N(N), //comment\n" // EOL comment after first param - " .M(M)\n" - " ) bq ();\n" - "endmodule\n"}, - {"module foo; bar #(.N(N),.M(M)//comment\n) bq ();endmodule\n", - "module foo;\n" - " bar #(\n" - " .N(N),\n" - " .M(M) //comment\n" // EOL comment after last param - " ) bq ();\n" - "endmodule\n"}, - {" module foo ; bar bq(aa,bb,cc);endmodule\n", - "module foo;\n" - " bar bq (\n" - " aa,\n" - " bb,\n" - " cc\n" - " );\n" // multiple positional ports, one per line - "endmodule\n"}, - {" module foo ; bar bq(aa,\n" - "`ifdef BB\n" - "bb,\n" - "`endif\n" - "cc);endmodule\n", - "module foo;\n" - " bar bq (\n" - " aa,\n" - "`ifdef BB\n" - " bb,\n" // keep same indentation as outside conditional - "`endif\n" - " cc\n" - " );\n" // multiple positional ports, one per line - "endmodule\n"}, - {" module foo ; bar bq(.aa,.bb);endmodule\n", - "module foo;\n" - " bar bq (\n" - " .aa,\n" - " .bb\n" - " );\n" // multiple named ports, one per line - "endmodule\n"}, - {" module foo ; bar bq(.aa(aa),.bb(bb));endmodule\n", - "module foo;\n" - " bar bq (\n" - " .aa(aa),\n" - " .bb(bb)\n" - " );\n" // multiple named ports, one per line - "endmodule\n"}, - {" module foo ; bar bq(.aa(aa),\n" - "`ifdef ZZ\n" - ".zz( zz ),\n" - "`else\n" - ".yy( yy ),\n" - "`endif\n" - ".bb(bb)\n" - ");endmodule\n", - "module foo;\n" - " bar bq (\n" - " .aa(aa),\n" - "`ifdef ZZ\n" - " .zz(zz),\n" - "`else\n" - " .yy(yy),\n" - "`endif\n" - " .bb(bb)\n" - " );\n" // multiple named ports, one per line - "endmodule\n"}, - {" module foo ; bar#(NNNNNNNN)" - "bq(.aa(aaaaaa),.bb(bbbbbb));endmodule\n", - "module foo;\n" - " bar #(NNNNNNNN) bq (\n" - " .aa(aaaaaa),\n" - " .bb(bbbbbb)\n" - " );\n" - "endmodule\n"}, - {" module foo ; barrrrrrr " - "bq(.aaaaaa(aaaaaa),.bbbbbb(bbbbbb));endmodule\n", - "module foo;\n" - " barrrrrrr bq (\n" - " .aaaaaa(aaaaaa),\n" - " .bbbbbb(bbbbbb)\n" - " );\n" - "endmodule\n"}, - {"module foo; bar #(.NNNNN(NNNNN)) bq (.bussss(bussss));endmodule\n", - // instance parameter and port does not fit on line - "module foo;\n" - " bar #(\n" - " .NNNNN(NNNNN)\n" - " ) bq (\n" - " .bussss(bussss)\n" - " );\n" - "endmodule\n"}, - {"module foo; bar #(//\n.N(N)) bq (.bus(bus));endmodule\n", - "module foo;\n" - " bar #( //\n" // would fit on one line, but forced to expand by // - " .N(N)\n" - " ) bq (\n" - " .bus(bus)\n" - " );\n" - "endmodule\n"}, - {"module foo; bar #(\n" - "`ifdef MM\n" - ".M(M)\n" - "`else\n" - ".N(N)\n" - "`endif\n" - ") bq (.bus(bus));endmodule\n", - "module foo;\n" - " bar #(\n" - "`ifdef MM\n" - " .M(M)\n" - "`else\n" - " .N(N)\n" - "`endif\n" - " ) bq (\n" - " .bus(bus)\n" - " );\n" - "endmodule\n"}, - {"module foo; bar #(.N(N)//\n) bq (.bus(bus));endmodule\n", - "module foo;\n" - " bar #(\n" // would fit on one line, but forced to expand by // - " .N(N) //\n" - " ) bq (\n" - " .bus(bus)\n" - " );\n" - "endmodule\n"}, - {"module foo; bar #(.N(N)) bq (//\n.bus(bus));endmodule\n", - "module foo;\n" - " bar #(\n" // would fit on one line, but forced to expand by // - " .N(N)\n" - " ) bq ( //\n" - " .bus(bus)\n" - " );\n" - "endmodule\n"}, - {"module foo; bar #(.N(N)) bq (.bus(bus)//\n);endmodule\n", - "module foo;\n" - " bar #(\n" // would fit on one line, but forced to expand by // - " .N(N)\n" - " ) bq (\n" - " .bus(bus) //\n" - " );\n" - "endmodule\n"}, - {" module foo ; bar " - "bq(.aaa(aaa),.bbb(bbb),.ccc(ccc),.ddd(ddd));endmodule\n", - "module foo;\n" - " bar bq (\n" - " .aaa(aaa),\n" // ports don't fit on one line, so expanded - " .bbb(bbb),\n" - " .ccc(ccc),\n" - " .ddd(ddd)\n" - " );\n" - "endmodule\n"}, - {" module foo ; bar " - "bq(.aa(aa),.bb(bb),.cc(cc),.dd(dd));endmodule\n", - "module foo;\n" - " bar bq (\n" - " .aa(aa),\n" // one named port per line - " .bb(bb),\n" - " .cc(cc),\n" - " .dd(dd)\n" - " );\n" - "endmodule\n"}, - {" module foo ; bar " - "bq(.aa(aa),//\n.bb(bb),.cc(cc),.dd(dd));endmodule\n", - "module foo;\n" - " bar bq (\n" - " .aa(aa), //\n" // forced to expand by // - " .bb(bb),\n" - " .cc(cc),\n" - " .dd(dd)\n" - " );\n" - "endmodule\n"}, - {" module foo ; bar " - "bq(.aa(aa),.bb(bb),.cc(cc),.dd(dd)//\n);endmodule\n", - "module foo;\n" - " bar bq (\n" - " .aa(aa),\n" - " .bb(bb),\n" - " .cc(cc),\n" - " .dd(dd) //\n" // forced to expand by // - " );\n" - "endmodule\n"}, - {// gate instantiation test - "module m;" - "and\tx0(a, \t\tb,c);" - "or\nx1(a, \n b, d);" - "endmodule\n", - "module m;\n" - " and x0 (a, b, c);\n" - " or x1 (a, b, d);\n" - "endmodule\n"}, - {// ifdef inside port actuals - "module m; foo bar (\n" - "`ifdef BAZ\n" - "`endif\n" - ") ;endmodule\n", - "module m;\n" - " foo bar (\n" - "`ifdef BAZ\n" - "`endif\n" - " );\n" - "endmodule\n"}, - {// ifdef inside port actuals after a port connection - "module m; foo bar ( .a (a) ,\n" - "`ifdef BAZ\n" - "`endif\n" - ") ;endmodule\n", - "module m;\n" - " foo bar (\n" - " .a(a),\n" - "`ifdef BAZ\n" - "`endif\n" - " );\n" - "endmodule\n"}, - {// ifdef inside port actuals before a port connection - "module m; foo bar (\n" - "`ifdef BAZ\n" - "`endif\n" - ". b(b) ) ;endmodule\n", - "module m;\n" - " foo bar (\n" - "`ifdef BAZ\n" - "`endif\n" - " .b(b)\n" - " );\n" - "endmodule\n"}, - {// ifdef-conditional port connection - "module m; foo bar (\n" - "`ifdef BAZ\n" - ". c (\tc) \n" - "`endif\n" - " ) ;endmodule\n", - "module m;\n" - " foo bar (\n" - "`ifdef BAZ\n" - " .c(c)\n" - "`endif\n" - " );\n" - "endmodule\n"}, - {// ifndef-else-conditional port connection - "module m; foo bar (\n" - "`ifndef BAZ\n" - ". c (\tc) \n" - " `else\n" - " . d(d\t)\n" - " `endif\n" - " ) ;endmodule\n", - "module m;\n" - " foo bar (\n" - "`ifndef BAZ\n" - " .c(c)\n" - "`else\n" - " .d(d)\n" - "`endif\n" - " );\n" - "endmodule\n"}, - - {// comment following a delay in next line - "module t;\n" - "reg x;\n" - "initial begin\n" - "#20\n" - "//comment\n" - "x = 1;\n" - "x = 2;\n" - "end\n" - "endmodule\n", - "module t;\n" - " reg x;\n" - " initial begin\n" - " #20\n" - " //comment\n" - " x = 1;\n" - " x = 2;\n" - " end\n" - "endmodule\n"}, - {// comment following a delay in the same line - "module t;\n" - "reg x;\n" - "initial begin\n" - "#20 //comment\n" - "x = 1;\n" - "x = 2;\n" - "end\n" - "endmodule\n", - "module t;\n" - " reg x;\n" - " initial begin\n" - " #20 //comment\n" - " x = 1;\n" - " x = 2;\n" - " end\n" - "endmodule\n"}, - // Macro calls inside [...] - {"module foo;\nlogic [`BAR(1)\n+2] foo;\nendmodule", - "module foo;\n" - " logic [`BAR(1)\n" - "+2] foo;\n" - "endmodule\n"}, - {"module foo;\nlogic [`BAR(1)+2] foo;\nendmodule", - "module foo;\n" - " logic [`BAR(1)+2] foo;\n" - "endmodule\n"}, - {"module foo ();\n function bar();\n " - "logic [12:34] data[`AAAAAAAAAAAAAAAAAAAAAAAA(1) : " - "`BBBBBBBBBBBBBBBBBBBBBBBB(2) + 3];\n " - "endfunction\nendmodule", - "module foo ();\n" - " function bar();\n" - " logic [12:34] data[\n" - " `AAAAAAAAAAAAAAAAAAAAAAAA(1) :\n" - " `BBBBBBBBBBBBBBBBBBBBBBBB(2) + 3];\n" - " endfunction\n" - "endmodule\n"}, - { - // test that alternate top-syntax mode works - "// verilog_syntax: parse-as-module-body\n" - "`define FOO\n", - "// verilog_syntax: parse-as-module-body\n" - "`define FOO\n", - }, - { - // test alternate parsing mode in macro expansion - "class foo;\n" - "`MY_MACRO(\n" - " // verilog_syntax: parse-as-statements\n" - " // EOL comment\n" - " int count;\n" - " if(cfg.enable) begin\n" - " count = 1;\n" - " end,\n" - " utils_pkg::decrement())\n" - "endclass\n", - "class foo;\n" - " `MY_MACRO(\n" - " // verilog_syntax: parse-as-statements\n" - " // EOL comment\n" - " int count;\n" - " if (cfg.enable) begin\n" - " count = 1;\n" - " end, utils_pkg::decrement())\n" - "endclass\n", - }, - - // tests top-level data declarations - {"a;", // implicit type - "a;\n"}, - {"a\tb;", // explicit type - "a b;\n"}, - {"a;b;", - "a;\n" - "b;\n"}, - {"a ,b;", // implicit type - "a, b;\n"}, - /* TODO(b/149591599): implicit type data declarations in module body - {"module\tm ;a ;endmodule", - "module m;\n" - " a;\n" - "endmodule\n"}, - */ - {"package\tp ;a ;endpackage", // implicit type - "package p;\n" - " a;\n" - "endpackage\n"}, - {"package\tp ;a ,b ;endpackage", // implicit type - "package p;\n" - " a, b;\n" - "endpackage\n"}, - {"package\tp ;a ;b ;endpackage", // implicit type - "package p;\n" - " a;\n" - " b;\n" - "endpackage\n"}, - /* TODO(b/149591627) : implicit type data declarations in class body - {"class\tc ;a ;endclass", - "class c;\n" - " a;\n" - "endclass\n"}, - */ - {"function\tf ;a ;endfunction", // implicit type - "function f;\n" - " a;\n" - "endfunction\n"}, - {"function\tf ;a ;x ;endfunction", // implicit type - "function f;\n" - " a;\n" - " x;\n" - "endfunction\n"}, - /* TODO(b/149592527): multi-variable data declaration as block_item_decl - // same inside tasks - {"function\tf ;a \t,x ;endfunction", // implicit type - "function f;\n" - " a, x;\n" - "endfunction\n"}, - */ - {"task\tt ;a ;endtask", // implicit type - "task t;\n" - " a;\n" - "endtask\n"}, - {"task\tt ;a ;x ;endtask", // implicit type - "task t;\n" - " a;\n" - " x;\n" - "endtask\n"}, - - {// tests bind declaration - "bind foo bar baz ( . clk ( clk ) ) ;", - "bind foo bar baz (.clk(clk));\n"}, - {// tests bind declaration, with type params - "bind foo bar# ( . W ( W ) ) baz ( . clk ( clk ) ) ;", - "bind foo bar #(.W(W)) baz (.clk(clk));\n"}, - {// tests bind declarations - "bind foo bar baz ( ) ;" - "bind goo car caz ( );", - "bind foo bar baz ();\n" - "bind goo car caz ();\n"}, - - {"bind blah foo #( .MaxCount(MaxCount), .MaxDelta(MaxDelta)) bar (" - " .clk(clk), .rst(rst), .value(value) );", - "bind blah foo #(\n" - " .MaxCount(MaxCount),\n" - " .MaxDelta(MaxDelta)\n" - ") bar (\n" - " .clk (clk),\n" - " .rst (rst),\n" - " .value(value)\n" - ");\n"}, - {"bind foo bar baz(\\\n" - "`undef d\\\n" - "`undef d);", - "bind foo bar baz (\\\n" - " `undef d\\\n" - " `undef d\n" - ");\n"}, - { - "bind expaaaaaaaaaaand_meeee looooooooong_name# (" - ".W(W_CONST), .H(H_CONST), .D(D_CONST) )" - "instaaance_name (.in(iiiiiiiin), .out(ooooooout), .clk(ccccccclk));", - "bind expaaaaaaaaaaand_meeee\n" - " looooooooong_name #(\n" - " .W(W_CONST),\n" - " .H(H_CONST),\n" - " .D(D_CONST)\n" - ") instaaance_name (\n" - " .in (iiiiiiiin),\n" - " .out(ooooooout),\n" - " .clk(ccccccclk)\n" - ");\n", - }, - - { - "bind expand_inst name# (" - ".W(W_CONST), .H(H_CONST), .D(D_CONST) )" - "instaaance_name (.in(iiiiiiiin), .out(ooooooout), .clk(ccccccclk));", - "bind expand_inst name #(\n" - " .W(W_CONST),\n" - " .H(H_CONST),\n" - " .D(D_CONST)\n" - ") instaaance_name (\n" - " .in (iiiiiiiin),\n" - " .out(ooooooout),\n" - " .clk(ccccccclk)\n" - ");\n", - }, - - { - // tests import declaration - "import foo_pkg :: bar ;", - "import foo_pkg::bar;\n", - }, - { - // tests import declaration with wildcard - "import foo_pkg :: * ;", - "import foo_pkg::*;\n", - }, - { - // tests import declarations - "import foo_pkg :: *\t;" - "import goo_pkg\n:: thing ;", - "import foo_pkg::*;\n" - "import goo_pkg::thing;\n", - }, - // preserve spaces inside [] dimensions, but limit spaces around ':' to one - // and adjust everything else - {"foo[W-1:0]a[0:K-1];", // data declaration - "foo [W-1:0] a[0:K-1];\n"}, - {"foo[W-1 : 0]a[0 : K-1];", "foo [W-1 : 0] a[0 : K-1];\n"}, - {"foo[W - 1 : 0 ]a [ 0 : K - 1] ;", - "foo [W - 1 : 0] a[0 : K - 1];\n"}, - // remove spaces between [...] [...] in multi-dimension arrays - {"foo[K] [W]a;", // - "foo [K][W] a;\n"}, - {"foo b [K] [W] ;", // - "foo b[K][W];\n"}, - {"logic[K:1] [W:1]a;", // - "logic [K:1][W:1] a;\n"}, - {"logic b [K:1] [W:1] ;", // - "logic b[K:1][W:1];\n"}, - // spaces in bit slicing - { - // preserve 0 spaces - "always_ff @(posedge clk) begin " - "dummy <=\tfoo [ 7:2 ] ; " - "end", - "always_ff @(posedge clk) begin\n" - " dummy <= foo[7:2];\n" - "end\n", - }, - { - // preserve 1 space - "always_ff @(posedge clk) begin " - "dummy <=\tfoo [ 7 : 2 ] ; " - "end", - "always_ff @(posedge clk) begin\n" - " dummy <= foo[7 : 2];\n" - "end\n", - }, - { - // limit multiple spaces to 1 - "always_ff @(posedge clk) begin " - "dummy <=\tfoo [ 7 : 2 ] ; " - "end", - "always_ff @(posedge clk) begin\n" - " dummy <= foo[7 : 2];\n" - "end\n", - }, - { - "always_ff @(posedge clk) begin " - "dummy <=\tfoo [ 7 : 2 ] ; " - "end", - "always_ff @(posedge clk) begin\n" - " dummy <= foo[7 : 2];\n" - "end\n", - }, - { - // keep value on the left when symmetrizing - "always_ff @(posedge clk) begin " - "dummy <=\tfoo [ 7: 2 ] ; " - "end", - "always_ff @(posedge clk) begin\n" - " dummy <= foo[7:2];\n" - "end\n", - }, - { - "always_ff @(posedge clk) begin " - "dummy <=\tfoo [ 7: 2 ] ; " - "end", - "always_ff @(posedge clk) begin\n" - " dummy <= foo[7:2];\n" - "end\n", - }, - { - "always_ff @(posedge clk) begin " - "dummy <=\tfoo [ 7 :2 ] ; " - "end", - "always_ff @(posedge clk) begin\n" - " dummy <= foo[7 : 2];\n" - "end\n", - }, - { - "always_ff @(posedge clk) begin " - "dummy <=\tfoo [ 7 : 2 ] ; " - "end", - "always_ff @(posedge clk) begin\n" - " dummy <= foo[7 : 2];\n" - "end\n", - }, - { - // use value on the left, but limit to 1 space - "always_ff @(posedge clk) begin " - "dummy <=\tfoo [ 7 :2 ] ; " - "end", - "always_ff @(posedge clk) begin\n" - " dummy <= foo[7 : 2];\n" - "end\n", - }, - - // task test cases - {"task t ;endtask:t", // - "task t;\n" - "endtask : t\n"}, - {"task t ;# 10 ;# 5ns ; # 0.1 ; # 1step ;endtask", - "task t;\n" - " #10;\n" // no space in delay expression - " #5ns;\n" - " #0.1;\n" - " #1step;\n" - "endtask\n"}, - {"task t\n;a<=b ;c<=d ;endtask\n", - "task t;\n" - " a <= b;\n" - " c <= d;\n" - "endtask\n"}, - {"class c; virtual protected task\tt ( foo bar);" - "a.a<=b.b;\t\tc.c\n<= d.d; endtask endclass", - "class c;\n" - " virtual protected task t(foo bar);\n" - " a.a <= b.b;\n" - " c.c <= d.d;\n" - " endtask\n" - "endclass\n"}, - {"task t;\n// statement comment\nendtask\n", - "task t;\n" - " // statement comment\n" // indented - "endtask\n"}, - {"task t( );\n// statement comment\nendtask\n", - "task t();\n" - " // statement comment\n" // indented - "endtask\n"}, - {"task t( input x );\n" - "// statement comment\n" - "s();\n" - "// statement comment\n" - "endtask\n", - "task t(input x);\n" - " // statement comment\n" // indented - " s();\n" - " // statement comment\n" // indented - "endtask\n"}, - {"task fj;fork join fork join\tendtask", - "task fj;\n" - " fork\n" - " join\n" - " fork\n" - " join\n" - "endtask\n"}, - {"task fj;fork join_any fork join_any\tendtask", - "task fj;\n" - " fork\n" - " join_any\n" - " fork\n" - " join_any\n" - "endtask\n"}, - {"task fj;fork join_none fork join_none\tendtask", - "task fj;\n" - " fork\n" - " join_none\n" - " fork\n" - " join_none\n" - "endtask\n"}, - {"task fj;fork\n" - "//c1\njoin\n" - "//c2\n" - "fork \n" - "//c3\n" - "join\tendtask", - "task fj;\n" - " fork\n" - " //c1\n" - " join\n" - " //c2\n" - " fork\n" - " //c3\n" - " join\n" - "endtask\n"}, - {"task fj;\n" - "fork " - "begin " - "end " - "foo();" - "begin " - "end " - "join_any endtask", - "task fj;\n" - " fork\n" - " begin\n" - " end\n" - " foo();\n" - " begin\n" - " end\n" - " join_any\n" - "endtask\n"}, - { - // call and assertion statements - "task t ;Fire() ;assert ( x);assert(y );endtask", - "task t;\n" - " Fire();\n" - " assert (x);\n" - " assert (y);\n" - "endtask\n", - }, - { - // assertion statements with body clause - "task t ;Fire() ;assert ( x) fee ( );assert(y ) foo ( ) ;endtask", - "task t;\n" - " Fire();\n" - " assert (x) fee();\n" - " assert (y) foo();\n" - "endtask\n", - }, - { - // assertion statements with else clause - "task t ;Fire() ;assert ( x) else fee ( );" - "assert(y ) else foo ( ) ;endtask", - "task t;\n" - " Fire();\n" - " assert (x)\n" - " else fee();\n" - " assert (y)\n" - " else foo();\n" - "endtask\n", - }, - { - // assertion statements with else clause - "task t ;Fire() ;assert ( x) fa(); else fee ( );" - "assert(y ) fi(); else foo ( ) ;endtask", - "task t;\n" - " Fire();\n" - " assert (x) fa();\n" - " else fee();\n" - " assert (y) fi();\n" - " else foo();\n" - "endtask\n", - }, - { - // assume statements - "task t ;Fire() ;assume ( x);assume(y );endtask", - "task t;\n" - " Fire();\n" - " assume (x);\n" - " assume (y);\n" - "endtask\n", - }, - { - // cover statements - "task t ;Fire() ;cover ( x);cover(y );endtask", - "task t;\n" - " Fire();\n" - " cover (x);\n" - " cover (y);\n" - "endtask\n", - }, - { - // cover statements, with action - "task t ;Fire() ;cover ( x)g( );cover(y ) h();endtask", - "task t;\n" - " Fire();\n" - " cover (x) g();\n" - " cover (y) h();\n" - "endtask\n", - }, - { - // cover statements, with action block - "task t ;Fire() ;cover ( x) begin g( ); end " - "cover(y ) begin h(); end endtask", - "task t;\n" - " Fire();\n" - " cover (x) begin\n" - " g();\n" - " end\n" - " cover (y) begin\n" - " h();\n" - " end\n" - "endtask\n", - }, - {// shuffle calls - "task t; foo. shuffle ( );bar .shuffle( ); endtask", - "task t;\n" - " foo.shuffle();\n" - " bar.shuffle();\n" - "endtask\n"}, - {// wait statements (null) - "task t; wait (a==b);wait(c<d); endtask", - "task t;\n" - " wait (a == b);\n" - " wait (c < d);\n" - "endtask\n"}, - {// wait statements, single action statement - "task t; wait (a==b) p();wait(c<d) q(); endtask", - "task t;\n" - " wait (a == b) p();\n" - " wait (c < d) q();\n" - "endtask\n"}, - {// wait statements, block action statement - "task t; wait (a==b) begin p(); end " - "wait(c<d) begin q(); end endtask", - "task t;\n" - " wait (a == b) begin\n" - " p();\n" - " end\n" - " wait (c < d) begin\n" - " q();\n" - " end\n" - "endtask\n"}, - {// wait fork statements - "task t ; wait\tfork;wait fork ;endtask", - "task t;\n" - " wait fork;\n" - " wait fork;\n" - "endtask\n"}, - {// labeled single statements (prefix-style) - "task t;l1:x<=y ;endtask", - "task t;\n" - " l1 : x <= y;\n" - "endtask\n"}, - {// labeled block statements (prefix-style) - "task t;l1:begin end:l1 endtask", - "task t;\n" - " l1 : begin\n" - " end : l1\n" - "endtask\n"}, - {// labeled seq block statements - "task t;begin:l1 end:l1 endtask", - "task t;\n" - " begin : l1\n" - " end : l1\n" - "endtask\n"}, - {// labeled par block statements - "task t;fork:l1 join:l1 endtask", - "task t;\n" - " fork : l1\n" - " join : l1\n" - "endtask\n"}, - {// task with disable statements - "task t ;fork\tjoin\tdisable\tfork;endtask", - "task t;\n" - " fork\n" - " join\n" - " disable fork;\n" - "endtask\n"}, - {"task t ;fork\tjoin_any\tdisable\tfork ;endtask", - "task t;\n" - " fork\n" - " join_any\n" - " disable fork;\n" - "endtask\n"}, - {"task t ;disable\tbean_counter ;endtask", - "task t;\n" - " disable bean_counter;\n" - "endtask\n"}, - { - // task with if-statement - "task t;" - "if (r == t)" - "a.b(c);" - "endtask", - "task t;\n" - " if (r == t) a.b(c);\n" - "endtask\n", - }, - { - // task with system call inside if header - "task t;" - "if (!$cast(ssssssssssssssss,vvvvvvvvvv,gggggggg))begin end endtask:t", - "task t;\n" - " if (!$cast(\n" - " ssssssssssssssss,\n" - " vvvvvvvvvv,\n" - " gggggggg\n" - " )) begin\n" - " end\n" - "endtask : t\n", - }, - { - // task with nested subtask call and arguments passed by name - "task t;" - "if (!$cast(ssssssssssssssss, vvvvvvvvvv.gggggggg(" - ".ppppppp(ppppppp)," - ".yyyyy(\"xxxxxxxxxxxxx\")" - "))) begin " - "end " - "endtask : t", - "task t;\n" - " if (!$cast(\n" - " ssssssssssssssss,\n" - " vvvvvvvvvv.gggggggg(\n" - " .ppppppp(ppppppp),\n" - " .yyyyy(\"xxxxxxxxxxxxx\")\n" - " )\n" - " )) begin\n" - " end\n" - "endtask : t\n", - }, - - { - // assert property statements - "task t ;assert property( x);assert\tproperty(y );endtask", - "task t;\n" - " assert property (x);\n" - " assert property (y);\n" - "endtask\n", - }, - { - // assert property statements, with action - "task t ;assert property( x) j();assert\tproperty(y )k( );endtask", - "task t;\n" - " assert property (x) j();\n" - " assert property (y) k();\n" - "endtask\n", - }, - { - // assert property statements, with action block - "task t ;assert property( x) begin j();end " - " assert\tproperty(y )begin\tk( ); end endtask", - "task t;\n" - " assert property (x) begin\n" - " j();\n" - " end\n" - " assert property (y) begin\n" - " k();\n" - " end\n" - "endtask\n", - }, - { - // assert property statements, else with null - "task t ;assert property( x) else;assert\tproperty(y )else;endtask", - "task t;\n" - " assert property (x)\n" - " else;\n" - " assert property (y)\n" - " else;\n" - "endtask\n", - }, - { - // assert property statements, else with actions - "task t ;assert property( x) f(); else p(); " - "\tassert\tproperty(y ) g();else q( );endtask", - "task t;\n" - " assert property (x) f();\n" - " else p();\n" - " assert property (y) g();\n" - " else q();\n" - "endtask\n", - }, - { - // assert property statement, with action block, else statement - "task t ;assert property( x) begin j();end else\tk( ); endtask", - "task t;\n" - " assert property (x) begin\n" - " j();\n" - " end else k();\n" - "endtask\n", - }, - { - // assert property statement, with action statement, else block - "task t ;assert property( x) j(); else begin\tk( );end endtask", - "task t;\n" - " assert property (x) j();\n" - " else begin\n" - " k();\n" - " end\n" - "endtask\n", - }, - { - // assert property statement, with action block, else block - "task t ;assert property( x)begin j();end " - "else begin\tk( );end endtask", - "task t;\n" - " assert property (x) begin\n" - " j();\n" - " end else begin\n" - " k();\n" - " end\n" - "endtask\n", - }, - - { - // assume property statements - "task t ;assume property( x);assume\tproperty(y );endtask", - "task t;\n" - " assume property (x);\n" - " assume property (y);\n" - "endtask\n", - }, - { - // assume property statements, with action - "task t ;assume property( x) j();assume\tproperty(y )k( );endtask", - "task t;\n" - " assume property (x) j();\n" - " assume property (y) k();\n" - "endtask\n", - }, - { - // assume property statements, with action block - "task t ;assume property( x) begin j();end " - " assume\tproperty(y )begin\tk( ); end endtask", - "task t;\n" - " assume property (x) begin\n" - " j();\n" - " end\n" - " assume property (y) begin\n" - " k();\n" - " end\n" - "endtask\n", - }, - { - // assume property statements, else with null - "task t ;assume property( x) else;assume\tproperty(y )else;endtask", - "task t;\n" - " assume property (x)\n" - " else;\n" - " assume property (y)\n" - " else;\n" - "endtask\n", - }, - { - // assume property statements, else with actions - "task t ;assume property( x) f(); else p(); " - "\tassume\tproperty(y ) g();else q( );endtask", - "task t;\n" - " assume property (x) f();\n" - " else p();\n" - " assume property (y) g();\n" - " else q();\n" - "endtask\n", - }, - { - // assume property statement, with action block, else statement - "task t ;assume property( x) begin j();end else\tk( ); endtask", - "task t;\n" - " assume property (x) begin\n" - " j();\n" - " end else k();\n" - "endtask\n", - }, - { - // assume property statement, with action statement, else block - "task t ;assume property( x) j(); else begin\tk( );end endtask", - "task t;\n" - " assume property (x) j();\n" - " else begin\n" - " k();\n" - " end\n" - "endtask\n", - }, - { - // assume property statement, with action block, else block - "task t ;assume property( x)begin j();end " - "else begin\tk( );end endtask", - "task t;\n" - " assume property (x) begin\n" - " j();\n" - " end else begin\n" - " k();\n" - " end\n" - "endtask\n", - }, - - { - // expect property statements - "task t ;expect ( x);expect\t(y );endtask", - "task t;\n" - " expect (x);\n" - " expect (y);\n" - "endtask\n", - }, - { - // expect property statements, with action - "task t ;expect ( x) j();expect\t(y )k( );endtask", - "task t;\n" - " expect (x) j();\n" - " expect (y) k();\n" - "endtask\n", - }, - { - // expect property statements, with action block - "task t ;expect ( x) begin j();end " - " expect\t(y )begin\tk( ); end endtask", - "task t;\n" - " expect (x) begin\n" - " j();\n" - " end\n" - " expect (y) begin\n" - " k();\n" - " end\n" - "endtask\n", - }, - { - // expect property statements, else with null - "task t ;expect ( x) else;expect\t(y )else;endtask", - "task t;\n" - " expect (x)\n" - " else;\n" - " expect (y)\n" - " else;\n" - "endtask\n", - }, - { - // expect property statements, else with actions - "task t ;expect ( x) f(); else p(); " - "\texpect\t(y ) g();else q( );endtask", - "task t;\n" - " expect (x) f();\n" - " else p();\n" - " expect (y) g();\n" - " else q();\n" - "endtask\n", - }, - { - // expect property statement, with action block, else statement - "task t ;expect ( x) begin j();end else\tk( ); endtask", - "task t;\n" - " expect (x) begin\n" - " j();\n" - " end else k();\n" - "endtask\n", - }, - { - // expect property statement, with action statement, else block - "task t ;expect ( x) j(); else begin\tk( );end endtask", - "task t;\n" - " expect (x) j();\n" - " else begin\n" - " k();\n" - " end\n" - "endtask\n", - }, - { - // expect property statement, with action block, else block - "task t ;expect ( x)begin j();end " - "else begin\tk( );end endtask", - "task t;\n" - " expect (x) begin\n" - " j();\n" - " end else begin\n" - " k();\n" - " end\n" - "endtask\n", - }, - - { - // cover property statements - "task t ;cover property( x);cover\tproperty(y );endtask", - "task t;\n" - " cover property (x);\n" - " cover property (y);\n" - "endtask\n", - }, - { - // cover property statements, with action - "task t ;cover property( x) j();cover\tproperty(y )k( );endtask", - "task t;\n" - " cover property (x) j();\n" - " cover property (y) k();\n" - "endtask\n", - }, - { - // cover property statements, with action block - "task t ;cover property( x) begin j();end " - " cover\tproperty(y )begin\tk( ); end endtask", - "task t;\n" - " cover property (x) begin\n" - " j();\n" - " end\n" - " cover property (y) begin\n" - " k();\n" - " end\n" - "endtask\n", - }, - - { - // cover sequence statements - "task t ;cover sequence( x);cover\tsequence(y );endtask", - "task t;\n" - " cover sequence (x);\n" - " cover sequence (y);\n" - "endtask\n", - }, - { - // cover sequence statements, with action - "task t ;cover sequence( x) j();cover\tsequence(y )k( );endtask", - "task t;\n" - " cover sequence (x) j();\n" - " cover sequence (y) k();\n" - "endtask\n", - }, - { - // cover sequence statements, with action block - "task t ;cover sequence( x) begin j();end " - " cover\tsequence(y )begin\tk( ); end endtask", - "task t;\n" - " cover sequence (x) begin\n" - " j();\n" - " end\n" - " cover sequence (y) begin\n" - " k();\n" - " end\n" - "endtask\n", - }, - - {// module with disable statements - "module m;always begin :block disable m.block; end endmodule", - "module m;\n" - " always begin : block\n" - " disable m.block;\n" - " end\n" - "endmodule\n"}, - {"module m;always begin disable m.block; end endmodule", - "module m;\n" - " always begin\n" - " disable m.block;\n" - " end\n" - "endmodule\n"}, - - // property test cases - {"module mp ;property p1 ; a|->b;endproperty endmodule", - "module mp;\n" - " property p1;\n" - " a |-> b;\n" - " endproperty\n" - "endmodule\n"}, - {"module mp ;property p1 ; a|->b;endproperty:p1 endmodule", - "module mp;\n" - " property p1;\n" - " a |-> b;\n" - " endproperty : p1\n" // with end label - "endmodule\n"}, - {"module mp ;property p1 ; a|->## 1 b;endproperty endmodule", - "module mp;\n" - " property p1;\n" - " a |-> ##1 b;\n" // with delay - " endproperty\n" - "endmodule\n"}, - {"module mp ;property p1 ; a|->## [0: 1] b;endproperty endmodule", - "module mp;\n" - " property p1;\n" - " a |-> ##[0:1] b;\n" // prefer no spaces with delay range - " endproperty\n" - "endmodule\n"}, - {"module mp ;property p1 ; a|->## [0 : 1] b;endproperty endmodule", - "module mp;\n" - " property p1;\n" - " a |-> ##[0 : 1] b;\n" // limit to one space, symmetrize - " endproperty\n" - "endmodule\n"}, - {"module mp ;property p1 ; a## 1 b;endproperty endmodule", - "module mp;\n" - " property p1;\n" - " a ##1 b;\n" - " endproperty\n" - "endmodule\n"}, - {"module mp ;property p1 ; (a^c)## 1 b;endproperty endmodule", - "module mp;\n" - " property p1;\n" - " (a ^ c) ##1 b;\n" - " endproperty\n" - "endmodule\n"}, - - // covergroup test cases - {// Minimal case - "covergroup c; endgroup\n", - "covergroup c;\n" - "endgroup\n"}, - {// Minimal useful case - "covergroup c @ (posedge clk); coverpoint a; endgroup\n", - "covergroup c @(posedge clk);\n" - " coverpoint a;\n" - "endgroup\n"}, - {// Multiple coverpoints - "covergroup foo @(posedge clk); coverpoint a; coverpoint b; " - "coverpoint c; coverpoint d; endgroup\n", - "covergroup foo @(posedge clk);\n" - " coverpoint a;\n" - " coverpoint b;\n" - " coverpoint c;\n" - " coverpoint d;\n" - "endgroup\n"}, - {// Multiple bins - "covergroup memory @ (posedge ce); address :coverpoint addr {" - "bins low={0,127}; bins high={128,255};} endgroup\n", - "covergroup memory @(posedge ce);\n" - " address: coverpoint addr {\n" - " bins low = {0, 127};\n" - " bins high = {128, 255};\n" - " }\n" - "endgroup\n"}, - {// Custom sample() function - "covergroup c with function sample(bit i); endgroup\n", - "covergroup c with function sample (\n" - " bit i\n" // test cases are wrapped at 40 - ");\n" - "endgroup\n"}, - - // comment-controlled formatter disabling - {"// verilog_format: off\n" // disables whole file - " `include \t\t \"path/to/file.vh\"\n", - "// verilog_format: off\n" - " `include \t\t \"path/to/file.vh\"\n"}, // keeps bad spacing - {"/* verilog_format: off */\n" // disables whole file - " `include \t\t \"path/to/file.svh\" \n", - "/* verilog_format: off */\n" - " `include \t\t \"path/to/file.svh\" \n"}, // keeps bad spacing - {"// verilog_format: on\n" // already enabled, no effect - " `include \t \"path/to/file.svh\" \t\n", - "// verilog_format: on\n" - "`include \"path/to/file.svh\"\n"}, - {"// verilog_format: off\n" - "// verilog_format: on\n" // re-enable right away - " `include \t\t \"path/to/file.svh\" \n", - "// verilog_format: off\n" - "// verilog_format: on\n" - "`include \"path/to/file.svh\"\n"}, - {"/* aaa *//* bbb */\n" // not formatting controls - " `include \t\t \"path/to/file.svh\" \n", // should format - "/* aaa */ /* bbb */\n" // currently inserts 2 spaces - "`include \"path/to/file.svh\"\n"}, - {"/* verilog_format: off *//* verilog_format: on */\n" // re-enable - " `include \t\t \"path/to/file.svh\" \n", - // Note that this case normally wouldn't fit in 40 columns, - // but disabling formatting lets it overflow. - "/* verilog_format: off *//* verilog_format: on */\n" - "`include \"path/to/file.svh\"\n"}, - {"// verilog_format: off\n" - " `include \t\t \"path/to/fileA.svh\" // verilog_format: on\n" - " `include \t\t \"path/to/fileB.svh\" \n", - // re-enable formatting with comment trailing other tokens - "// verilog_format: off\n" - " `include \t\t \"path/to/fileA.svh\" // verilog_format: on\n" - "`include \"path/to/fileB.svh\"\n"}, - {" `include \t\t \"path/to/file1.vh\" \n" // format this - "// verilog_format: off\n" // start disabling - " `include \t\t \"path/to/file2.vh\" \n" - "\t\t\n" - " `include \t\t \"path/to/file3.vh\" \n" - "// verilog_format: on\n" // stop disabling - " `include \t\t \"path/to/file4.vh\" \n", // format this - "`include \"path/to/file1.vh\"\n" - "// verilog_format: off\n" // start disabling - " `include \t\t \"path/to/file2.vh\" \n" - "\t\t\n" - " `include \t\t \"path/to/file3.vh\" \n" - "// verilog_format: on\n" // stop disabling - "`include \"path/to/file4.vh\"\n"}, - {// disabling formatting on a module (to end of file) - "// verilog_format: off\n" - "module m;endmodule\n", - "// verilog_format: off\n" - "module m;endmodule\n"}, - {// disabling formatting on a module (to end of file) - "// verilog_format: off\n" - "module m;\n" - "unindented instantiation;\n" - "endmodule\n", - "// verilog_format: off\n" - "module m;\n" - "unindented instantiation;\n" - "endmodule\n"}, - {// disabling formatting inside a port declaration list disables alignment, - // but falls back to standard compaction. - "module align_off(\n" - "input w ,\n" - " // verilog_format: off\n" - "input wire [y:z] wwww,\n" - " // verilog_format: on\n" - "output reg xx\n" - ");\n" - "endmodule", - "module align_off (\n" - " input w ,\n" // preserved because group is partially disabled - " // verilog_format: off\n" - "input wire [y:z] wwww,\n" // not compacted - " // verilog_format: on\n" - " output reg xx\n" // preserved because group is partially disabled - ");\n" - "endmodule\n"}, - - {// multiple tokens with EOL comment - "module please; // don't break before the comment\n" - "endmodule\n", - "module please\n" - " ; // don't break before the comment\n" - "endmodule\n"}, - {// one token with EOL comment - "module please;\n" - "endmodule // don't break before the comment\n", - "module please;\n" - "endmodule // don't break before the comment\n"}, - { - // line with only an EOL comment - "module wild;\n" - "// a really long comment on its own line to be left alone\n" - "endmodule", - "module wild;\n" - " // a really long comment on its own line to be left alone\n" - "endmodule\n", - }, - { - // primitive declaration - "primitive primitive1(o, s, r);output o;reg o;input s;input r;table 1 " - "? :" - " ? : 0; ? 1 : 0 : -; endtable endprimitive", - "primitive primitive1(o, s, r);\n" - " output o;\n" - " reg o;\n" - " input s;\n" - " input r;\n" - " table\n" - " 1 ? : ? : 0;\n" - " ? 1 : 0 : -;\n" - " endtable\n" - "endprimitive\n", - }, - { - // one-input combinatorial UDP - "primitive primitive1 ( o,i ) ;output o;input i;" - " table 1 : 0 ; 0 : 1 ; endtable endprimitive", - "primitive primitive1(o, i);\n" - " output o;\n" - " input i;\n" - " table\n" - " 1 : 0;\n" - " 0 : 1;\n" - " endtable\n" - "endprimitive\n", - }, - { - // two-input combinatorial UDP - "primitive primitive2(o, s, r);output o;input s;input r;" - "table 1 ? : 0;? 1 : -; endtable endprimitive", - "primitive primitive2(o, s, r);\n" - " output o;\n" - " input s;\n" - " input r;\n" - " table\n" - " 1 ? : 0;\n" - " ? 1 : -;\n" - " endtable\n" - "endprimitive\n", - }, - { - // ten-input combinatorial UDP - "primitive comb10(o, i0, i1, i2, i3, i4, i5, i6, i7, i8, i9);" - "output o;input i0, i1, i2, i3, i4, i5, i6, i7, i8, i9;" - "table 0 ? ? ? ? ? ? ? ? 0 : 0;1 ? ? ? ? ? ? ? ? 0 : 1;" - "1 ? ? ? ? ? ? ? ? 1 : 1;0 ? ? ? ? ? ? ? ? 1 : 0;endtable endprimitive", - "primitive comb10(o, i0, i1, i2, i3, i4,\n" - " i5, i6, i7, i8, i9);\n" - " output o;\n" - " input i0, i1, i2, i3, i4, i5, i6, i7,\n" - " i8, i9;\n" - " table\n" - " 0 ? ? ? ? ? ? ? ? 0 : 0;\n" - " 1 ? ? ? ? ? ? ? ? 0 : 1;\n" - " 1 ? ? ? ? ? ? ? ? 1 : 1;\n" - " 0 ? ? ? ? ? ? ? ? 1 : 0;\n" - " endtable\n" - "endprimitive\n", - }, - { - // sequential level-sensitive UDP - "primitive level_seq(o, c, d);output o;reg o;" - " input c;input d;table\n" - "// C D state O\n" - "0 ? : ? : -; // No Change\n" - "? 0 : 0 : 0; // Unknown\n" - "endtable endprimitive", - "primitive level_seq(o, c, d);\n" - " output o;\n" - " reg o;\n" - " input c;\n" - " input d;\n" - " table\n" - " // C D state O\n" - " 0 ? : ? : -; // No Change\n" - " ? 0 : 0 : 0; // Unknown\n" - " endtable\n" - "endprimitive\n", - }, - { - // sequential edge-sensitive UDP - "primitive edge_seq(o, c, d);output o;reg o;input c;input d;" - "table (01) 0 : ? : 0;(01) 1 : ? : 1;(0?) 1 : 1 : 1;(0?) 0 : 0 : " - "0;\n" - "// ignore negative c\n" - "(?0) ? : ? : -;\n" - "// ignore changes on steady c\n" - "? (?\?) : ? : -; endtable endprimitive", - "primitive edge_seq(o, c, d);\n" - " output o;\n" - " reg o;\n" - " input c;\n" - " input d;\n" - " table\n" - " (01) 0 : ? : 0;\n" - " (01) 1 : ? : 1;\n" - " (0?) 1 : 1 : 1;\n" - " (0?) 0 : 0 : 0;\n" - " // ignore negative c\n" - " (?0) ? : ? : -;\n" - " // ignore changes on steady c\n" - " ? (?\?) : ? : -;\n" - " endtable\n" - "endprimitive\n", - }, - { - // mixed sequential UDP - "primitive mixed(o, clk, j, k, preset, clear);output o;reg o;" - "input c;input j, k;input preset, clear;table " - "? ?? 01:?:1 ; // preset logic\n" - "? ?? *1:1:1 ;? ?? 10:?:0 ; // clear logic\n" - "? ?? 1*:0:0 ;r 00 00:0:1 ; // normal\n" - "r 00 11:?:- ;r 01 11:?:0 ;r 10 11:?:1 ;r 11 11:0:1 ;" - "r 11 11:1:0 ;f ?? ??:?:- ;b *? ??:?:- ;" - " // j and k\n" - "b ?* ??:?:- ;endtable endprimitive\n", - "primitive mixed(o, clk, j, k, preset,\n" - " clear);\n" - " output o;\n" - " reg o;\n" - " input c;\n" - " input j, k;\n" - " input preset, clear;\n" - " table\n" - " ? ? ? 0 1 : ? : 1; // preset logic\n" - " ? ? ? * 1 : 1 : 1;\n" - " ? ? ? 1 0 : ? : 0; // clear logic\n" - " ? ? ? 1 * : 0 : 0;\n" - " r 0 0 0 0 : 0 : 1; // normal\n" - " r 0 0 1 1 : ? : -;\n" - " r 0 1 1 1 : ? : 0;\n" - " r 1 0 1 1 : ? : 1;\n" - " r 1 1 1 1 : 0 : 1;\n" - " r 1 1 1 1 : 1 : 0;\n" - " f ? ? ? ? : ? : -;\n" - " b * ? ? ? : ? : -; // j and k\n" - " b ? * ? ? : ? : -;\n" - " endtable\n" - "endprimitive\n", - }, - // un-lexed multiline macro arg token - { - " task S ; " - "`ppgJH3JoxhwyTmZ2dgPiuMQzpRAWiSs(" - "{xYtxuh6.FIMcVPEWfhtoI2FSe, xYtxuh6.ZVL5XASVGLYz32} == " - "SqRgavM[15:2];\n" - "JgQLBG == 4'h0;, \"foo\" )\n" - "endtask\n", - "task S;\n" - " `ppgJH3JoxhwyTmZ2dgPiuMQzpRAWiSs(\n" - " {xYtxuh6.FIMcVPEWfhtoI2FSe, xYtxuh6.ZVL5XASVGLYz32} == " - "SqRgavM[15:2];\n" - "JgQLBG == 4'h0;,\n" - " \"foo\")\n" - "endtask\n", - }, - - // module instantiation named ports tabular alignment - //{// module instantiation with no port, only comments - // "module m;\n" - // "foo bar(\n" - // "\t//comment1\n" - // "//comment2\n" - // ");\n" - // "endmodule\n", - // "module m;\n" - // " foo bar (\n" - // " //comment1\n" - // " //comment2\n" - // " );\n" - // "endmodule\n" - //}, - {// all named ports - "module m;\n" - "foo bar(.a(a), .aa(aa), .aaa(aaa));\n" - "endmodule\n", - "module m;\n" - " foo bar (\n" - " .a (a),\n" - " .aa (aa),\n" - " .aaa(aaa)\n" - " );\n" - "endmodule\n"}, - {// named ports left unconnected - "module m;\n" - "foo bar(.a(), .aa(), .aaa());\n" - "endmodule\n", - "module m;\n" - " foo bar (\n" - " .a (),\n" - " .aa (),\n" - " .aaa()\n" - " );\n" - "endmodule\n"}, - {// multiple named ports groups separated by blank line - "module m;\n" - "foo bar(.a(a), .aaa(aaa),\n\n .b(b), .bbbbbb(bbbbb));\n" - "endmodule\n", - "module m;\n" - " foo bar (\n" - " .a (a),\n" - " .aaa(aaa),\n" - "\n" - " .b (b),\n" - " .bbbbbb(bbbbb)\n" - " );\n" - "endmodule\n"}, - {// named ports with concatenation - "module m;\n" - "foo bar(.a(a), .aaa({a,b,c}));\n" - "endmodule\n", - "module m;\n" - " foo bar (\n" - " .a (a),\n" - " .aaa({a, b, c})\n" - " );\n" - "endmodule\n"}, - {// name ports with slices - "module m;\n" - "foo bar(.a(a), .aaa(q[r:s]));\n" - "endmodule\n", - "module m;\n" - " foo bar (\n" - " .a (a),\n" - " .aaa(q[r:s])\n" - " );\n" - "endmodule\n"}, - {// named ports with pre-proc directives - "module m;\n" - "foo bar(.a(a), `ifdef MACRO .aa(aa), `endif .aaa(aaa));\n" - "endmodule\n", - "module m;\n" - " foo bar (\n" - " .a (a),\n" - "`ifdef MACRO\n" - " .aa (aa),\n" - "`endif\n" - " .aaa(aaa)\n" - " );\n" - "endmodule\n"}, - {// named ports with macros - "module m;\n" - "foo bar(.a(a), .aa(aa[`RANGE]), .aaa(aaa));\n" - "endmodule\n", - "module m;\n" - " foo bar (\n" - " .a (a),\n" - " .aa (aa[`RANGE]),\n" - " .aaa(aaa)\n" - " );\n" - "endmodule\n"}, - {"module m;\n" - "foo bar(.a(a), .AA, .aaa(aaa));\n" - "endmodule\n", - "module m;\n" - " foo bar (\n" - " .a (a),\n" - " .AA,\n" - " .aaa(aaa)\n" - " );\n" - "endmodule\n"}, - {// name ports with comments - "module m;\n" - "foo bar(.a(a), .aa(aa)/*comment*/, .aaa(aaa));\n" - "endmodule\n", - "module m;\n" - " foo bar (\n" - " .a (a),\n" - " .aa (aa) /*comment*/,\n" - " .aaa(aaa)\n" - " );\n" - "endmodule\n"}, - {"module m;\n" - "foo bar(.a(a),//comment1\n .aaa(aaa)//comment2\n);\n" - "endmodule\n", - "module m;\n" - " foo bar (\n" - " .a (a), //comment1\n" - " .aaa(aaa) //comment2\n" - " );\n" - "endmodule\n"}, - {"module m;\n" - "foo bar(.a(a),\n" - " //.aa(aa),\n" - ".aaa(aaa));\n" - "endmodule\n", - "module m;\n" - " foo bar (\n" - " .a (a),\n" - " //.aa(aa),\n" - " .aaa(aaa)\n" - " );\n" - "endmodule\n"}, - {"module m;\n" - "foo bar(\n" - ".a(a) //comment1\n" - ", .aaa(aaa) //comment2\n" - ") //comment3\n" - ";\n" - "endmodule\n", - "module m;\n" - " foo bar (\n" - " .a (a) //comment1\n" - " , .aaa(aaa) //comment2\n" - " ) //comment3\n" - " ;\n" - "endmodule\n"}, - {// module instantiation with all implicit connections - "module m;\n" - "foo bar(.a, .aa, .aaaaa);\n" - "endmodule\n", - "module m;\n" - " foo bar (\n" - " .a,\n" - " .aa,\n" - " .aaaaa\n" - " );\n" - "endmodule\n"}, - {// named ports corssed with implicit connections - "module m;\n" - "foo bar(.a(a), .aa, .aaaaa(aaaaa));\n" - "endmodule\n", - "module m;\n" - " foo bar (\n" - " .a (a),\n" - " .aa,\n" - " .aaaaa(aaaaa)\n" - " );\n" - "endmodule\n"}, - {// named ports corssed with wildcard connections - "module m;\n" - "foo bar(.a(a), .aaa(aaa), .*);\n" - "endmodule\n", - "module m;\n" - " foo bar (\n" - " .a (a),\n" - " .aaa(aaa),\n" - " .*\n" - " );\n" - "endmodule\n"}, - {"module m;\n" - "foo bar(.a(a), .aa(aa), .* , .aaa(aaa));\n" - "endmodule\n", - "module m;\n" - " foo bar (\n" - " .a (a),\n" - " .aa (aa),\n" - " .*,\n" - " .aaa(aaa)\n" - " );\n" - "endmodule\n"}, - - // Parameterized data types, declarations inside #() tabular alignment - {// parameterized module with 'list_of_param_assignments' - "module foo #(A = 2, AA = 22, AAA = 222);\n" - "endmodule\n", - "module foo #(\n" - " A = 2,\n" - " AA = 22,\n" - " AAA = 222\n" - ");\n" - "endmodule\n"}, - {// parameterized module with 'parameter_declaration' - "module foo #(parameter int a = 2, parameter int aa = 22);\n" - "endmodule\n", - "module foo #(\n" - " parameter int a = 2,\n" - " parameter int aa = 22\n" - ");\n" - "endmodule\n"}, - {// parameterized module with 'parameter_declaration' and comments - "module foo #(//comment\nparameter int a = 2, parameter int aa = 22);\n" - "endmodule\n", - "module foo #( //comment\n" - " parameter int a = 2,\n" - " parameter int aa = 22\n" - ");\n" - "endmodule\n"}, - {// parameterized module with 'parameter_declaration' and trailing comments - "module foo #(parameter int a = 2,//comment\n parameter int aa = 22);\n" - "endmodule\n", - "module foo #(\n" - " parameter int a = 2, //comment\n" - " parameter int aa = 22\n" - ");\n" - "endmodule\n"}, - {// parameterized module with 'parameter_declaration' and pre-proc - "module foo #(parameter int a = 2,\n" - "`ifdef MACRO parameter int aa = 22, `endif\n" - "parameter int aaa = 222);\n" - "endmodule\n", - "module foo #(\n" - " parameter int a = 2,\n" - "`ifdef MACRO\n" - " parameter int aa = 22,\n" - "`endif\n" - " parameter int aaa = 222\n" - ");\n" - "endmodule\n"}, - {// parameterized module with 'parameter_declaration' and packed dimensions - "module foo #(parameter logic [3:0] a = 2, parameter logic [30:0] aa = " - "22);\n" - "endmodule\n", - "module foo #(\n" - " parameter logic [ 3:0] a = 2,\n" - " parameter logic [30:0] aa = 22\n" - ");\n" - "endmodule\n"}, - {// parameterized module with 'parameter_declaration' and unpacked - // dimensions - "module foo #(parameter logic a[3:0] = 2, parameter logic aa [30:0] = " - "22);\n" - "endmodule\n", - "module foo #(\n" - " parameter logic a [ 3:0] = 2,\n" - " parameter logic aa[30:0] = 22\n" - ");\n" - "endmodule\n"}, - - {// parameterized module with 'local_parameter_declaration' - "module foo #(localparam int a = 2, localparam int aa = 22);\n" - "endmodule\n", - "module foo #(\n" - " localparam int a = 2,\n" - " localparam int aa = 22\n" - ");\n" - "endmodule\n"}, - {// parameterized module with 'local_parameter_declaration' and comments - "module foo #(//comment\nlocalparam int a = 2, localparam int aa = 22);\n" - "endmodule\n", - "module foo #( //comment\n" - " localparam int a = 2,\n" - " localparam int aa = 22\n" - ");\n" - "endmodule\n"}, - {// parameterized module with 'local_parameter_declaration' and trailing - // comments - "module foo #(localparam int a = 2,//comment\n localparam int aa = 22);\n" - "endmodule\n", - "module foo #(\n" - " localparam int a = 2, //comment\n" - " localparam int aa = 22\n" - ");\n" - "endmodule\n"}, - {// parameterized module with 'local_parameter_declaration' and pre-proc - "module foo #(localparam int a = 2,\n" - "`ifdef MACRO localparam int aa = 22, `endif\n" - "localparam int aaa = 222);\n" - "endmodule\n", - "module foo #(\n" - " localparam int a = 2,\n" - "`ifdef MACRO\n" - " localparam int aa = 22,\n" - "`endif\n" - " localparam int aaa = 222\n" - ");\n" - "endmodule\n"}, - {// parameterized module with 'local_parameter_declaration' and packed - // dimensions - "module foo #(localparam logic [3:0] a = 2, localparam logic [30:0] aa = " - "22);\n" - "endmodule\n", - "module foo #(\n" - " localparam logic [ 3:0] a = 2,\n" - " localparam logic [30:0] aa = 22\n" - ");\n" - "endmodule\n"}, - {// parameterized module with 'local_parameter_declaration' and unpacked - // dimensions - "module foo #(localparam logic a[3:0] = 2, localparam logic aa [30:0] = " - "22);\n" - "endmodule\n", - "module foo #(\n" - " localparam logic a [ 3:0] = 2,\n" - " localparam logic aa[30:0] = 22\n" - ");\n" - "endmodule\n"}, - - {// parameterized module with 'data_type list_of_param_assignments' - "module foo #( int a = 2, real aa = 22, longint aaa = 222);\n" - "endmodule\n", - "module foo #(\n" - " int a = 2,\n" - " real aa = 22,\n" - " longint aaa = 222\n" - ");\n" - "endmodule\n"}, - {// parameterized module with 'data_type list_of_param_assignments' and - // comments - "module foo #(//comment\nint a = 2, shortreal aa = 22, longint aaa = " - "222);\n" - "endmodule\n", - "module foo #( //comment\n" - " int a = 2,\n" - " shortreal aa = 22,\n" - " longint aaa = 222\n" - ");\n" - "endmodule\n"}, - {// parameterized module with 'data_type list_of_param_assignments' and - // trailing comments - "module foo #(int a = 2, shortreal aa = 22,//comment\n longint aaa = " - "222);\n" - "endmodule\n", - "module foo #(\n" - " int a = 2,\n" - " shortreal aa = 22, //comment\n" - " longint aaa = 222\n" - ");\n" - "endmodule\n"}, - {// parameterized module with 'data_type list_of_param_assignments' and - // pre-proc - "module foo #(int a = 2,\n" - "`ifdef MACRO shortreal aa = 22, `endif\n" - " longint aaa = 222);\n" - "endmodule\n", - "module foo #(\n" - " int a = 2,\n" - "`ifdef MACRO\n" - " shortreal aa = 22,\n" - "`endif\n" - " longint aaa = 222\n" - ");\n" - "endmodule\n"}, - {// parameterized module with 'data_type list_of_param_assignments' and - // packed dimensions - "module foo #(bit [1:0] a = 2, reg [12:0] aa = 22, logic [123:0] aaa = " - "222);\n" - "endmodule\n", - "module foo #(\n" - " bit [ 1:0] a = 2,\n" - " reg [ 12:0] aa = 22,\n" - " logic [123:0] aaa = 222\n" - ");\n" - "endmodule\n"}, - {// parameterized module with 'data_type list_of_param_assignments' and - // unpacked dimensions - "module foo #(bit a[1:0] = 2, reg aa[12:0] = 22, logic aaa [123:0] = " - "222);\n" - "endmodule\n", - "module foo #(\n" - " bit a [ 1:0] = 2,\n" - " reg aa [ 12:0] = 22,\n" - " logic aaa[123:0] = 222\n" - ");\n" - "endmodule\n"}, - {// parameterized module with 'type list_of_type_assignments' - "module foo #(type T = int, type TT = bit, type TTT= C#(logic) );\n" - "endmodule\n", - "module foo #(\n" - " type T = int,\n" - " type TT = bit,\n" - " type TTT = C#(logic)\n" - ");\n" - "endmodule\n"}, - {// parameterized module with 'type list_of_type_assignments' and comments - "module foo #(//comment\ntype T = int, type TT = bit, type TTT= C#(logic) " - ");\n" - "endmodule\n", - "module foo #( //comment\n" - " type T = int,\n" - " type TT = bit,\n" - " type TTT = C#(logic)\n" - ");\n" - "endmodule\n"}, - {// parameterized module with 'data_type list_of_param_assignments' and - // trailing comments - "module foo #(type T = int, type TT = bit, //comment\n type TTT= " - "C#(logic) );\n" - "endmodule\n", - "module foo #(\n" - " type T = int,\n" - " type TT = bit, //comment\n" - " type TTT = C#(logic)\n" - ");\n" - "endmodule\n"}, - {// parameterized module with 'data_type list_of_param_assignments' and - // pre-proc - "module foo #(type T = int,\n" - "`ifdef MACRO type TT = bit, `endif\n" - " type TTT= C#(logic));\n" - "endmodule\n", - "module foo #(\n" - " type T = int,\n" - "`ifdef MACRO\n" - " type TT = bit,\n" - "`endif\n" - " type TTT = C#(logic)\n" - ");\n" - "endmodule\n"}, - {// parameterized module with 'data_type list_of_param_assignments' and - // packed dimensions - "module foo #(type T = int [3:0], type TT = bit [250:0]);\n" - "endmodule\n", - "module foo #(\n" - " type T = int [ 3:0],\n" - " type TT = bit [250:0]\n" - ");\n" - "endmodule\n"}, - {"module foo #(type T = int, " - "A = 2, int AA = 22, parameter AAA = 222, parameter longint AAAA = 2222, " - "localparam AAAAA = 22222, localparam real AAAAAA = 222222" - ");\n" - "endmodule\n", - "module foo #(\n" - " type T = int,\n" - " A = 2,\n" - " int AA = 22,\n" - " parameter AAA = 222,\n" - " parameter longint AAAA = 2222,\n" - " localparam AAAAA = 22222,\n" - " localparam real AAAAAA = 222222\n" - ");\n" - "endmodule\n"}, - {// parameterized module with built-in data type - "module foo #(int a = 2, real abc = 2234);\n" - "endmodule\n", - "module foo #(\n" - " int a = 2,\n" - " real abc = 2234\n" - ");\n" - "endmodule\n"}, - {// parameterized module with type - "module foo #(type TYPE1 = int, type TYPE2 = boo);\n" - "endmodule\n", - "module foo #(\n" - " type TYPE1 = int,\n" - " type TYPE2 = boo\n" - ");\n" - "endmodule\n"}, - {"module foo#(localparam type TYPE1 = int, type TYPE22 = bool, parameter " - " type TYPE333 = real);\n" - "endmodule\n", - "module foo #(\n" - " localparam type TYPE1 = int,\n" - " type TYPE22 = bool,\n" - " parameter type TYPE333 = real\n" - ");\n" - "endmodule\n"}, - {// parameterized module with 'data_type list_of_param_assignments' and 1D - // packed dimensions - "module foo #(parameter type T = int [3:0], type TT = bit [123:0]);\n" - "endmodule\n", - "module foo #(\n" - " parameter type T = int [ 3:0],\n" - " type TT = bit [123:0]\n" - ");\n" - "endmodule\n"}, - {// parameterized module with 'data_type list_of_param_assignments' and 2D - // packed dimensions - "module foo #(type T = int [3:0][123:0], type TT = bit [123:0][1:0]);\n" - "endmodule\n", - "module foo #(\n" - " type T = int [ 3:0][123:0],\n" - " type TT = bit [123:0][ 1:0]\n" - ");\n" - "endmodule\n"}, - {// parametrized module with user defined data types - "module foo #(type T = my_type1_t, type TT = my_pkg::my_type2_t);\n" - "endmodule\n", - "module foo #(\n" - " type T = my_type1_t,\n" - " type TT = my_pkg::my_type2_t\n" - ");\n" - "endmodule\n"}, - - {// parameterized class with 'list_of_param_assignments' - "class foo #(A = 2, AA = 22, AAA = 222);\n" - "endclass\n", - "class foo #(\n" - " A = 2,\n" - " AA = 22,\n" - " AAA = 222\n" - ");\n" - "endclass\n"}, - {// parameterized class with 'parameter_declaration' - "class foo #(parameter int a = 2, parameter int aa = 22);\n" - "endclass\n", - "class foo #(\n" - " parameter int a = 2,\n" - " parameter int aa = 22\n" - ");\n" - "endclass\n"}, - {// parameterized class with 'parameter_declaration' and comments - "class foo #(//comment\nparameter int a = 2, parameter int aa = 22);\n" - "endclass\n", - "class foo #( //comment\n" - " parameter int a = 2,\n" - " parameter int aa = 22\n" - ");\n" - "endclass\n"}, - {// parameterized class with 'parameter_declaration' and trailing comments - "class foo #(parameter int a = 2,//comment\n parameter int aa = 22);\n" - "endclass\n", - "class foo #(\n" - " parameter int a = 2, //comment\n" - " parameter int aa = 22\n" - ");\n" - "endclass\n"}, - {// parameterized class with 'parameter_declaration' and pre-proc - "class foo #(parameter int a = 2,\n" - "`ifdef MACRO parameter int aa = 22, `endif\n" - "parameter int aaa = 222);\n" - "endclass\n", - "class foo #(\n" - " parameter int a = 2,\n" - "`ifdef MACRO\n" - " parameter int aa = 22,\n" - "`endif\n" - " parameter int aaa = 222\n" - ");\n" - "endclass\n"}, - {// parameterized class with 'parameter_declaration' and packed dimensions - "class foo #(parameter logic [3:0] a = 2, parameter logic [30:0] aa = " - "22);\n" - "endclass\n", - "class foo #(\n" - " parameter logic [ 3:0] a = 2,\n" - " parameter logic [30:0] aa = 22\n" - ");\n" - "endclass\n"}, - {// parameterized class with 'parameter_declaration' and unpacked dimensions - "class foo #(parameter logic a[3:0] = 2, parameter logic aa [30:0] = " - "22);\n" - "endclass\n", - "class foo #(\n" - " parameter logic a [ 3:0] = 2,\n" - " parameter logic aa[30:0] = 22\n" - ");\n" - "endclass\n"}, - - {// parameterized class with 'local_parameter_declaration' - "class foo #(localparam int a = 2, localparam int aa = 22);\n" - "endclass\n", - "class foo #(\n" - " localparam int a = 2,\n" - " localparam int aa = 22\n" - ");\n" - "endclass\n"}, - {// parameterized class with 'local_parameter_declaration' and comments - "class foo #(//comment\nlocalparam int a = 2, localparam int aa = 22);\n" - "endclass\n", - "class foo #( //comment\n" - " localparam int a = 2,\n" - " localparam int aa = 22\n" - ");\n" - "endclass\n"}, - {// parameterized class with 'local_parameter_declaration' and trailing - // comments - "class foo #(localparam int a = 2,//comment\n localparam int aa = 22);\n" - "endclass\n", - "class foo #(\n" - " localparam int a = 2, //comment\n" - " localparam int aa = 22\n" - ");\n" - "endclass\n"}, - {// parameterized class with 'local_parameter_declaration' and pre-proc - "class foo #(localparam int a = 2,\n" - "`ifdef MACRO localparam int aa = 22, `endif\n" - "localparam int aaa = 222);\n" - "endclass\n", - "class foo #(\n" - " localparam int a = 2,\n" - "`ifdef MACRO\n" - " localparam int aa = 22,\n" - "`endif\n" - " localparam int aaa = 222\n" - ");\n" - "endclass\n"}, - {// parameterized class with 'local_parameter_declaration' and packed - // dimensions - "class foo #(localparam logic [3:0] a = 2, localparam logic [30:0] aa = " - "22);\n" - "endclass\n", - "class foo #(\n" - " localparam logic [ 3:0] a = 2,\n" - " localparam logic [30:0] aa = 22\n" - ");\n" - "endclass\n"}, - {// parameterized class with 'local_parameter_declaration' and unpacked - // dimensions - "class foo #(localparam logic a[3:0] = 2, localparam logic aa [30:0] = " - "22);\n" - "endclass\n", - "class foo #(\n" - " localparam logic a [ 3:0] = 2,\n" - " localparam logic aa[30:0] = 22\n" - ");\n" - "endclass\n"}, - {// parameterized class with 'data_type list_of_param_assignments' - "class foo #( int a = 2, real aa = 22, longint aaa = 222);\n" - "endclass\n", - "class foo #(\n" - " int a = 2,\n" - " real aa = 22,\n" - " longint aaa = 222\n" - ");\n" - "endclass\n"}, - {// parameterized class with 'data_type list_of_param_assignments' and - // comments - "class foo #(//comment\nint a = 2, shortreal aa = 22, longint aaa = " - "222);\n" - "endclass\n", - "class foo #( //comment\n" - " int a = 2,\n" - " shortreal aa = 22,\n" - " longint aaa = 222\n" - ");\n" - "endclass\n"}, - {// parameterized class with 'data_type list_of_param_assignments' and - // trailing comments - "class foo #(int a = 2, shortreal aa = 22,//comment\n longint aaa = " - "222);\n" - "endclass\n", - "class foo #(\n" - " int a = 2,\n" - " shortreal aa = 22, //comment\n" - " longint aaa = 222\n" - ");\n" - "endclass\n"}, - {// parameterized class with 'data_type list_of_param_assignments' and - // pre-proc - "class foo #(int a = 2,\n" - "`ifdef MACRO shortreal aa = 22, `endif\n" - " longint aaa = 222);\n" - "endclass\n", - "class foo #(\n" - " int a = 2,\n" - "`ifdef MACRO\n" - " shortreal aa = 22,\n" - "`endif\n" - " longint aaa = 222\n" - ");\n" - "endclass\n"}, - {// parameterized class with 'data_type list_of_param_assignments' and - // packed dimensions - "class foo #(bit [1:0] a = 2, reg [12:0] aa = 22, logic [123:0] aaa = " - "222);\n" - "endclass\n", - "class foo #(\n" - " bit [ 1:0] a = 2,\n" - " reg [ 12:0] aa = 22,\n" - " logic [123:0] aaa = 222\n" - ");\n" - "endclass\n"}, - {// parameterized class with 'data_type list_of_param_assignments' and - // unpacked dimensions - "class foo #(bit a[1:0] = 2, reg aa[12:0] = 22, logic aaa [123:0] = " - "222);\n" - "endclass\n", - "class foo #(\n" - " bit a [ 1:0] = 2,\n" - " reg aa [ 12:0] = 22,\n" - " logic aaa[123:0] = 222\n" - ");\n" - "endclass\n"}, - {// parameterized class with 'type list_of_type_assignments' - "class foo #(type T = int, type TT = bit, type TTT= C#(logic) );\n" - "endclass\n", - "class foo #(\n" - " type T = int,\n" - " type TT = bit,\n" - " type TTT = C#(logic)\n" - ");\n" - "endclass\n"}, - {// parameterized class with 'type list_of_type_assignments' and comments - "class foo #(//comment\ntype T = int, type TT = bit, type TTT= C#(logic) " - ");\n" - "endclass\n", - "class foo #( //comment\n" - " type T = int,\n" - " type TT = bit,\n" - " type TTT = C#(logic)\n" - ");\n" - "endclass\n"}, - {// parameterized class with 'data_type list_of_param_assignments' and - // trailing comments - "class foo #(type T = int, type TT = bit, //comment\n type TTT= C#(logic) " - ");\n" - "endclass\n", - "class foo #(\n" - " type T = int,\n" - " type TT = bit, //comment\n" - " type TTT = C#(logic)\n" - ");\n" - "endclass\n"}, - {// parameterized class with 'data_type list_of_param_assignments' and - // pre-proc - "class foo #(type T = int,\n" - "`ifdef MACRO type TT = bit, `endif\n" - " type TTT= C#(logic));\n" - "endclass\n", - "class foo #(\n" - " type T = int,\n" - "`ifdef MACRO\n" - " type TT = bit,\n" - "`endif\n" - " type TTT = C#(logic)\n" - ");\n" - "endclass\n"}, - {// parameterized class with 'data_type list_of_param_assignments' and - // packed dimensions - "class foo #(type T = int [3:0], type TT = bit [250:0]);\n" - "endclass\n", - "class foo #(\n" - " type T = int [ 3:0],\n" - " type TT = bit [250:0]\n" - ");\n" - "endclass\n"}, - {"class foo #(type T = int, " - "A = 2, int AA = 22, parameter AAA = 222, parameter longint AAAA = 2222, " - "localparam AAAAA = 22222, localparam real AAAAAA = 222222" - ");\n" - "endclass\n", - "class foo #(\n" - " type T = int,\n" - " A = 2,\n" - " int AA = 22,\n" - " parameter AAA = 222,\n" - " parameter longint AAAA = 2222,\n" - " localparam AAAAA = 22222,\n" - " localparam real AAAAAA = 222222\n" - ");\n" - "endclass\n"}, - {// parameterized class with built-in data type - "class foo #(int a = 2, real abc = 2234);\n" - "endclass\n", - "class foo #(\n" - " int a = 2,\n" - " real abc = 2234\n" - ");\n" - "endclass\n"}, - {// parameterized class with type - "class foo #(type TYPE1 = int, type TYPE2 = boo);\n" - "endclass\n", - "class foo #(\n" - " type TYPE1 = int,\n" - " type TYPE2 = boo\n" - ");\n" - "endclass\n"}, - {"class foo#(localparam type TYPE1 = int, type TYPE22 = bool, parameter " - "type TYPE333 = real);\n" - "endclass\n", - "class foo #(\n" - " localparam type TYPE1 = int,\n" - " type TYPE22 = bool,\n" - " parameter type TYPE333 = real\n" - ");\n" - "endclass\n"}, - {// parameterized class with 'data_type list_of_param_assignments' and 1D - // packed dimensions - "class foo #(parameter type T = int [3:0], type TT = bit [123:0]);\n" - "endclass\n", - "class foo #(\n" - " parameter type T = int [ 3:0],\n" - " type TT = bit [123:0]\n" - ");\n" - "endclass\n"}, - {// parameterized class with 'data_type list_of_param_assignments' and 2D - // packed dimensions - "class foo #(type T = int [3:0][123:0], type TT = bit [123:0][1:0]);\n" - "endclass\n", - "class foo #(\n" - " type T = int [ 3:0][123:0],\n" - " type TT = bit [123:0][ 1:0]\n" - ");\n" - "endclass\n"}, - {// parametrized class with user defined data types - "class foo #(type T = my_type1_t, type TT = my_pkg::my_type2_t);\n" - "endclass\n", - "class foo #(\n" - " type T = my_type1_t,\n" - " type TT = my_pkg::my_type2_t\n" - ");\n" - "endclass\n"}, - - {// parameterized interface with 'local_parameter_declaration' - "interface foo #(localparam int a = 2, localparam int aa = 22);\n" - "endinterface\n", - "interface foo #(\n" - " localparam int a = 2,\n" - " localparam int aa = 22\n" - ");\n" - "endinterface\n"}, - {// parameterized interface with 'local_parameter_declaration' and comments - "interface foo #(//comment\nlocalparam int a = 2, localparam int aa = " - "22);\n" - "endinterface\n", - "interface foo #( //comment\n" - " localparam int a = 2,\n" - " localparam int aa = 22\n" - ");\n" - "endinterface\n"}, - {// parameterized interface with 'local_parameter_declaration' and trailing - // comments - "interface foo #(localparam int a = 2,//comment\n localparam int aa = " - "22);\n" - "endinterface\n", - "interface foo #(\n" - " localparam int a = 2, //comment\n" - " localparam int aa = 22\n" - ");\n" - "endinterface\n"}, - {// parameterized interface with 'local_parameter_declaration' and pre-proc - "interface foo #(localparam int a = 2,\n" - "`ifdef MACRO localparam int aa = 22, `endif\n" - "localparam int aaa = 222);\n" - "endinterface\n", - "interface foo #(\n" - " localparam int a = 2,\n" - "`ifdef MACRO\n" - " localparam int aa = 22,\n" - "`endif\n" - " localparam int aaa = 222\n" - ");\n" - "endinterface\n"}, - {// parameterized interface with 'local_parameter_declaration' and packed - // dimensions - "interface foo #(localparam logic [3:0] a = 2, localparam logic [30:0] aa " - "= 22);\n" - "endinterface\n", - "interface foo #(\n" - " localparam logic [ 3:0] a = 2,\n" - " localparam logic [30:0] aa = 22\n" - ");\n" - "endinterface\n"}, - {// parameterized interface with 'local_parameter_declaration' and unpacked - // dimensions - "interface foo #(localparam logic a[3:0] = 2, localparam logic aa [30:0] " - "= 22);\n" - "endinterface\n", - "interface foo #(\n" - " localparam logic a [ 3:0] = 2,\n" - " localparam logic aa[30:0] = 22\n" - ");\n" - "endinterface\n"}, - {// parameterized interface with 'data_type list_of_param_assignments' - "interface foo #( int a = 2, real aa = 22, longint aaa = 222);\n" - "endinterface\n", - "interface foo #(\n" - " int a = 2,\n" - " real aa = 22,\n" - " longint aaa = 222\n" - ");\n" - "endinterface\n"}, - {// parameterized interface with 'data_type list_of_param_assignments' and - // comments - "interface foo #(//comment\nint a = 2, shortreal aa = 22, longint aaa = " - "222);\n" - "endinterface\n", - "interface foo #( //comment\n" - " int a = 2,\n" - " shortreal aa = 22,\n" - " longint aaa = 222\n" - ");\n" - "endinterface\n"}, - {// parameterized interface with 'data_type list_of_param_assignments' and - // trailing comments - "interface foo #(int a = 2, shortreal aa = 22,//comment\n longint aaa = " - "222);\n" - "endinterface\n", - "interface foo #(\n" - " int a = 2,\n" - " shortreal aa = 22, //comment\n" - " longint aaa = 222\n" - ");\n" - "endinterface\n"}, - {// parameterized interface with 'data_type list_of_param_assignments' and - // pre-proc - "interface foo #(int a = 2,\n" - "`ifdef MACRO shortreal aa = 22, `endif\n" - " longint aaa = 222);\n" - "endinterface\n", - "interface foo #(\n" - " int a = 2,\n" - "`ifdef MACRO\n" - " shortreal aa = 22,\n" - "`endif\n" - " longint aaa = 222\n" - ");\n" - "endinterface\n"}, - {// parameterized interface with 'data_type list_of_param_assignments' and - // packed dimensions - "interface foo #(bit [1:0] a = 2, reg [12:0] aa = 22, logic [123:0] aaa " - "= 222);\n" - "endinterface\n", - "interface foo #(\n" - " bit [ 1:0] a = 2,\n" - " reg [ 12:0] aa = 22,\n" - " logic [123:0] aaa = 222\n" - ");\n" - "endinterface\n"}, - {// parameterized interface with 'data_type list_of_param_assignments' and - // unpacked dimensions - "interface foo #(bit a[1:0] = 2, reg aa[12:0] = 22, logic aaa [123:0] " - "= 222);\n" - "endinterface\n", - "interface foo #(\n" - " bit a [ 1:0] = 2,\n" - " reg aa [ 12:0] = 22,\n" - " logic aaa[123:0] = 222\n" - ");\n" - "endinterface\n"}, - {// parameterized interface with 'type list_of_type_assignments' - "interface foo #(type T = int, type TT = bit, type TTT= C#(logic) );\n" - "endinterface\n", - "interface foo #(\n" - " type T = int,\n" - " type TT = bit,\n" - " type TTT = C#(logic)\n" - ");\n" - "endinterface\n"}, - {// parameterized interface with 'type list_of_type_assignments' and - // comments - "interface foo #(//comment\ntype T = int, type TT = bit, type TTT= " - "C#(logic) );\n" - "endinterface\n", - "interface foo #( //comment\n" - " type T = int,\n" - " type TT = bit,\n" - " type TTT = C#(logic)\n" - ");\n" - "endinterface\n"}, - {// parameterized interface with 'data_type list_of_param_assignments' and - // trailing comments - "interface foo #(type T = int, type TT = bit, //comment\n type TTT= " - "C#(logic) );\n" - "endinterface\n", - "interface foo #(\n" - " type T = int,\n" - " type TT = bit, //comment\n" - " type TTT = C#(logic)\n" - ");\n" - "endinterface\n"}, - {// parameterized interface with 'data_type list_of_param_assignments' and - // pre-proc - "interface foo #(type T = int,\n" - "`ifdef MACRO type TT = bit, `endif\n" - " type TTT= C#(logic));\n" - "endinterface\n", - "interface foo #(\n" - " type T = int,\n" - "`ifdef MACRO\n" - " type TT = bit,\n" - "`endif\n" - " type TTT = C#(logic)\n" - ");\n" - "endinterface\n"}, - {// parameterized interface with 'data_type list_of_param_assignments' and - // packed dimensions - "interface foo #(type T = int [3:0], type TT = bit [250:0]);\n" - "endinterface\n", - "interface foo #(\n" - " type T = int [ 3:0],\n" - " type TT = bit [250:0]\n" - ");\n" - "endinterface\n"}, - {"interface foo #(type T = int, " - "A = 2, int AA = 22, parameter AAA = 222, parameter longint AAAA = 2222, " - "localparam AAAAA = 22222, localparam real AAAAAA = 222222" - ");\n" - "endinterface\n", - "interface foo #(\n" - " type T = int,\n" - " A = 2,\n" - " int AA = 22,\n" - " parameter AAA = 222,\n" - " parameter longint AAAA = 2222,\n" - " localparam AAAAA = 22222,\n" - " localparam real AAAAAA = 222222\n" - ");\n" - "endinterface\n"}, - {// parameterized interface with built-in data type - "interface foo #(int a = 2, real abc = 2234);\n" - "endinterface\n", - "interface foo #(\n" - " int a = 2,\n" - " real abc = 2234\n" - ");\n" - "endinterface\n"}, - {// parameterized interface with type - "interface foo #(type TYPE1 = int, type TYPE2 = boo);\n" - "endinterface\n", - "interface foo #(\n" - " type TYPE1 = int,\n" - " type TYPE2 = boo\n" - ");\n" - "endinterface\n"}, - {"interface foo#(localparam type TYPE1 = int, type TYPE22 = bool, " - "parameter type TYPE333 = real);\n" - "endinterface\n", - "interface foo #(\n" - " localparam type TYPE1 = int,\n" - " type TYPE22 = bool,\n" - " parameter type TYPE333 = real\n" - ");\n" - "endinterface\n"}, - {// parameterized interface with 'data_type list_of_param_assignments' and - // 1D packed dimensions - "interface foo #(parameter type T = int [3:0], type TT = bit [123:0]);\n" - "endinterface\n", - "interface foo #(\n" - " parameter type T = int [ 3:0],\n" - " type TT = bit [123:0]\n" - ");\n" - "endinterface\n"}, - {// parameterized interface with 'data_type list_of_param_assignments' and - // 2D packed dimensions - "interface foo #(type T = int [3:0][123:0], type TT = bit [123:0][1:0]);\n" - "endinterface\n", - "interface foo #(\n" - " type T = int [ 3:0][123:0],\n" - " type TT = bit [123:0][ 1:0]\n" - ");\n" - "endinterface\n"}, - {// parametrized interface with user defined data types - "interface foo #(type T = my_type1_t, type TT = my_pkg::my_type2_t);\n" - "endinterface\n", - "interface foo #(\n" - " type T = my_type1_t,\n" - " type TT = my_pkg::my_type2_t\n" - ");\n" - "endinterface\n"}, - {// wildcard import package at module header - "module foo import bar::*; (baz); endmodule\n", - "module foo\n" - " import bar::*;\n" - "(\n" - " baz\n" - ");\n" - "endmodule\n"}, - {// import package at module header - "module foo import bar::baz; (qux); endmodule\n", - "module foo\n" - " import bar::baz;\n" - "(\n" - " qux\n" - ");\n" - "endmodule\n"}, - {// wildcard import multiple packages at module header - "module foo import bar::*,baz::*; (qux); endmodule\n", - "module foo\n" - " import bar::*, baz::*;\n" - "(\n" - " qux\n" - ");\n" - "endmodule\n"}, - {// separate package import declarations in module header - "module foo import bar::*,baz::*; import q_pkg::qux; (qux); endmodule\n", - "module foo\n" - " import bar::*, baz::*;\n" - " import q_pkg::qux;\n" - "(\n" - " qux\n" - ");\n" - "endmodule\n"}, - {// import package at module header - "module foo import bar::baz; #(int p = 3)(qux); endmodule\n", - "module foo\n" - " import bar::baz;\n" - "#(\n" - " int p = 3\n" - ") (\n" - " qux\n" - ");\n" - "endmodule\n"}, - // Space between return keyword and return value - {"function int foo(logic [31:0] data); return{<<8{data}}; endfunction", - "function int foo(logic [31:0] data);\n" - " return {<<8{data}};\n" - "endfunction\n"}, - {"function int f;return(1);endfunction", - "function int f;\n" - " return (1);\n" - "endfunction\n"}, - {"function int f;return-1;endfunction", - "function int f;\n" - " return -1;\n" - "endfunction\n"}, - {"function int f ;return ! x\n;endfunction", - "function int f;\n" - " return !x;\n" - "endfunction\n"}, - {"function int f ;return ~ x\n;endfunction", - "function int f;\n" - " return ~x;\n" - "endfunction\n"}, - {"function int f ;return $x\n;endfunction", - "function int f;\n" - " return $x;\n" - "endfunction\n"}, - // String initializers - {"string a[] = {\n\"a\"\n};\n", "string a[] = {\"a\"};\n"}, - {"string abc[] = {\n\"a\",\n\"b\",\n\"c\"\n};\n", - "string abc[] = {\"a\", \"b\", \"c\"};\n"}, - {"string abc[] = {\n" - "\"a\",//\n" - "\"b\", \"c\"\n" - "};\n", - "string abc[] = {\"a\", //\n" - " \"b\",\n" - " \"c\"};\n"}, - {"string abc[] = {//\n" - "\"a\", \"b\", \"c\"" - "};\n", - "string abc[] = { //\n" - " \"a\",\n" - " \"b\",\n" - " \"c\"\n" - "};\n"}, - {"string abc[] = {\n" - "\"a\", \"b\", \"c\"//\n" - "};\n", - "string abc[] = {\"a\",\n" - " \"b\",\n" - " \"c\" //\n" - " };\n"}, - {"string abc[] = {//\n" - "\"a\",//\n" - "\"b\", \"c\"//\n" - "};\n", - "string abc[] = { //\n" - " \"a\", //\n" - " \"b\",\n" - " \"c\" //\n" - "};\n"}, - {"string abc[] = {\n" - "\"a\",\n" - "// comment\n" - "// comment\n" - "\"b\",\n" - "\"c\"\n" - "};\n", - "string abc[] = {\"a\",\n" - " // comment\n" - " // comment\n" - " \"b\",\n" - " \"c\"};\n"}, - {"string numbers[] = {\"one\", \"two\", \"three\", \"four\"};\n", - "string numbers[] = {\"one\",\n" - " \"two\",\n" - " \"three\",\n" - " \"four\"};\n"}, - {"string numbers[] = {\"one\", \"two\", THREE, \"four\"};\n", - "string numbers[] = {\n" - " \"one\", \"two\", THREE, \"four\"\n" - "};\n"}, - {"string numbers[] = {\"one\", {\"two\", \"three\"}, \"four\"};\n", - "string numbers[] = {\n" - " \"one\", {\"two\", \"three\"}, \"four\"\n" - "};\n"}, - {"string numbers[] = {\"one\", {\"two\", //\n" - "\"three\"}, \"four\"};\n", - "string numbers[] = {\n" - " \"one\",\n" - " {\n" - " \"two\", //\n" - " \"three\"\n" - " },\n" - " \"four\"\n" - "};\n"}, - {"string years[] = {\"two_thousand_nineteen\", \"two_thousand_twenty\",\n" - "\"two_thousand_twenty_one\"};\n", - // line with 3rd string would exceed column limit in unwrapped style - "string years[] = {\n" - " \"two_thousand_nineteen\",\n" - " \"two_thousand_twenty\",\n" - " \"two_thousand_twenty_one\"\n" - "};\n"}, - {"class class_name;\n" - "var_type var_name = new(\"the_string\");\n" - "endclass\n", - "class class_name;\n" - " var_type var_name = new(\"the_string\");\n" - "endclass\n"}, - - //{ // parameterized class with 'parameter_declaration' and MACRO - // "class foo #(parameter int a = 2,\n" - // "parameter int aaa = `MACRO);\n" - // "endclass\n", - // "class foo #(\n" - // " parameter int a = 2,\n" - // " parameter int aaa = `MACRO\n" - // ");\n" - // "endclass\n" - //}, - // Struct/Union alignment - {"typedef struct {\n" - "bit [3:0] first; bit [31:0] second; generic_type_name_t third;\n" - "} type_t;", - "typedef struct {\n" - " bit [3:0] first;\n" - " bit [31:0] second;\n" - " generic_type_name_t third;\n" - "} type_t;\n"}, - {"typedef union soft packed {\n" - "bit [3:0] first; bit [31:0] second; generic_type_name_t third;\n" - "} type_t;", - "typedef union soft packed {\n" - " bit [3:0] first;\n" - " bit [31:0] second;\n" - " generic_type_name_t third;\n" - "} type_t;\n"}, - {"typedef union soft {\n" - "bit [3:0] first; bit [31:0] second; generic_type_name_t third;\n" - "} type_t;", - "typedef union soft {\n" - " bit [3:0] first;\n" - " bit [31:0] second;\n" - " generic_type_name_t third;\n" - "} type_t;\n"}, - {"typedef struct {\n" - "// comment\n" - "bit [3:0] first; bit [31:0] second; generic_type_name_t third;\n" - "} type_t;", - "typedef struct {\n" - " // comment\n" - " bit [3:0] first;\n" - " bit [31:0] second;\n" - " generic_type_name_t third;\n" - "} type_t;\n"}, - {"typedef struct {\n" - "// comment 0\n" - "bit [31:0] first; // a\n" - "bit [31:0] second; // b\n" - "bit third; // c\n" - "uint fourth; // d\n" - "\n" - "// comment 1\n" - "int fifth;\n" - "// comment 2.1\n" - "// comment 2.2\n" - "uint sixth;\n" - "} timing_cfg_t;", - "typedef struct {\n" - " // comment 0\n" - " bit [31:0] first; // a\n" - " bit [31:0] second; // b\n" - " bit third; // c\n" - " uint fourth; // d\n" - "\n" - " // comment 1\n" - " int fifth;\n" - " // comment 2.1\n" - " // comment 2.2\n" - " uint sixth;\n" - "} timing_cfg_t;\n"}, - {"typedef struct {\n" - "// comment\n" - "rand int r;\n" - "int a;\n" - "int aa = 0;\n" - "int aaa = 1; // comment\n" - "foo#(bar) z;\n" - "int [x:y] zz; // comment\n" - "int zzz[a:b];\n" - "} type_t;", - "typedef struct {\n" - " // comment\n" - " rand int r;\n" - " int a;\n" - " int aa = 0;\n" - " int aaa = 1; // comment\n" - " foo #(bar) z;\n" - " int [x:y] zz; // comment\n" - " int zzz[a:b];\n" - "} type_t;\n"}, - {"typedef struct packed {\n" - "struct packed { bit q; logic qq; logic qqq; } a_few_qs;\n" - "struct packed {\n" - "logic [1:0] q;\n" - "} one_q;\n" - "int q;\n" - "uint qq;\n" - "} nested_qs_t;", - "typedef struct packed {\n" - " struct packed {\n" - " bit q;\n" - " logic qq;\n" - " logic qqq;\n" - " } a_few_qs;\n" - " struct packed {logic [1:0] q;} one_q;\n" - " int q;\n" - " uint qq;\n" - "} nested_qs_t;\n"}, - {"typedef struct packed {\n" - "struct packed { bit q; logic qq; logic qqq; } a_few_qs;\n" - "struct packed {\n" - "// comment\n" - "logic [1:0] q;\n" - "} one_q;\n" - "int q;\n" - "uint qq;\n" - "} nested_qs_t;", - "typedef struct packed {\n" - " struct packed {\n" - " bit q;\n" - " logic qq;\n" - " logic qqq;\n" - " } a_few_qs;\n" - " struct packed {\n" - " // comment\n" - " logic [1:0] q;\n" - " } one_q;\n" - " int q;\n" - " uint qq;\n" - "} nested_qs_t;\n"}, - {"typedef struct {bit [3:0] first;\n" - "`ifdef MACRO\n" - "bit [31:0] second; generic_type_name_t third;\n" - "`endif\n" - "} type_t;\n", - "typedef struct {\n" - " bit [3:0] first;\n" - "`ifdef MACRO\n" - " bit [31:0] second;\n" - " generic_type_name_t third;\n" - "`endif\n" - "} type_t;\n"}, - {"typedef struct {\n" - "bit [3:0] first // c\n" - "; bit [31:0] second" - "// c\n" - "; generic_type_name_t third // c\n" - ";} type_t;\n", - "typedef struct {\n" - " bit [3:0] first // c\n" - ";\n" - " bit [31:0] second // c\n" - ";\n" - " generic_type_name_t third // c\n" - ";\n" - "} type_t;\n"}, - {"struct {logic test1; // c\n" - "logic test2;} test3;\n", - "struct {\n" - " logic test1; // c\n" - " logic test2;\n" - "} test3;\n"}, - {"struct {\n" - " /* t */ logic test1; /* t */\n" - "/* t */ logic test2; }test3;\n", - "struct {\n" - " /* t */ logic test1; /* t */\n" - " /* t */ logic test2;\n" - "} test3;\n"}, - // Continuation comment alignment - {"`define BAR 1 // A\n" - "module foo(); // B\n" - "wire baz; // C\n" - "endmodule:foo // D\n", - "`define BAR 1 // A\n" - "module foo (); // B\n" - " wire baz; // C\n" - "endmodule : foo // D\n"}, - {"`define BAR 1 // A\n" - "module foo(); // B\n" - " // B.1\n" - " // B.2\n" - "wire baz; // C\n" - " // C.1\n" - " // C.2\n" - "endmodule:foo // D\n" - " // D.1\n" - " // D.2\n", - "`define BAR 1 // A\n" - "module foo (); // B\n" - " // B.1\n" - " // B.2\n" - " wire baz; // C\n" - " // C.1\n" - " // C.2\n" - "endmodule : foo // D\n" - " // D.1\n" - " // D.2\n"}, - {"// W\n" - "`define BAR 1 // A\n" - " // X\n" - "module foo(); // B\n" - " // B.1\n" - " // B.2\n" - " // Y\n" - "wire baz; // C\n" - " // C.1\n" - " // C.2\n" - " // Z\n" - "endmodule:foo // D\n" - " // D.1\n" - " // D.2\n", - "// W\n" - "`define BAR 1 // A\n" - "// X\n" - "module foo (); // B\n" - " // B.1\n" - " // B.2\n" - " // Y\n" - " wire baz; // C\n" - " // C.1\n" - " // C.2\n" - " // Z\n" - "endmodule : foo // D\n" - " // D.1\n" - " // D.2\n"}, - {"module foo( // A\n" - " // A.1\n" - "// X\n" - "input wire i1 [a:b], // B\n" - " // B.1\n" - "input [c:d] i2, // C\n" - " // C.1\n" - "\n" - "// Y\n" - "output reg o1 // D\n" - " // D.1\n" - ");endmodule:foo\n", - "module foo ( // A\n" - " // A.1\n" - " // X\n" - " input wire i1[a:b], // B\n" - " // B.1\n" - " input [c:d] i2, // C\n" - " // C.1\n" - "\n" - " // Y\n" - " output reg o1 // D\n" - " // D.1\n" - ");\n" - "endmodule : foo\n"}, - // user defined type alignment - { - "module foo();\n" - " logic [5:0][5:0] net_c;\n" - " messy_type_name [1:0] net_e;\n" - "endmodule\n", - "module foo ();\n" - " logic [5:0][5:0] net_c;\n" - " messy_type_name [1:0] net_e;\n" - "endmodule\n", - }, - // Continuation comment's original starting column is allowed to differ from - // starting comment's original starting column at most by 1. - // Starting column of comments B and C will change after formatting. - // TODO: refine the column alignment depending on current vs previous line. - // https://github.com/chipsalliance/verible/pull/858#discussion_r672844015 - {"module foo (); // A\n" // Starting comment; already on correct column - " // A.1\n" // A's column + 1 - " // A.2\n" // A's column - 1 - "wire baz; // B\n" // Starting comment; will be moved left - " // B.1\n" // B's column - 1 - " // B.2\n" // B's column + 1 - " // B.3\n" // B's column - "endmodule:foo // C\n" // Starting comment; will be moved right - " // C.1\n" // C's column + 1 - " // C.2\n", // C's column - 1 - "module foo (); // A\n" - " // A.1\n" - " // A.2\n" - " wire baz; // B\n" - " // B.1\n" - " // B.2\n" - " // B.3\n" - "endmodule : foo // C\n" - " // C.1\n" - " // C.2\n"}, - {"module foo\n" - "#(\n" - " parameter type baz_t = struct packed { `BAZ(); }\n" - ")\n" - "();\n" - "endmodule\n", - "module foo #(\n" - " parameter type\n" - " baz_t = struct packed {\n" - " `BAZ();\n" - " }\n" - ") ();\n" - "endmodule\n"}, - // The same as the previous test case, but without a semicolon at the macro - // call - {"module foo\n" - "#(\n" - " parameter type baz_t = struct packed { `BAZ() }\n" - ")\n" - "();\n" - "endmodule\n", - "module foo #(\n" - " parameter type\n" - " baz_t = struct packed {\n" - " `BAZ()\n" - " }\n" - ") ();\n" - "endmodule\n"}, - // Check that comments with too large starting column difference are not - // aligned as continuation comments. - // Check that starting comments are not linked with a comment in - // comment-only line above them, even when the starting column is the same. - // All comments in this test case are aligned independently, i.e. none are - // "continuation comments". - {" // comment1\n" // A's column, but is above it - "module foo (); // A\n" - " // comment2\n" // A's column + 2 - " // comment3\n" // A's column - 2 - "wire baz; // B\n" - " // comment4\n" // B's column - 2 - " // comment5\n" // B's column + 2 - " // comment6\n" // B's column, but not directly under B - "endmodule:foo // C\n" - " // comment7\n" // C's column + 2 - " // comment8\n", // C's column, but not directly under B - "// comment1\n" - "module foo (); // A\n" - " // comment2\n" - " // comment3\n" - " wire baz; // B\n" - " // comment4\n" - " // comment5\n" - " // comment6\n" - "endmodule : foo // C\n" - "// comment7\n" - "// comment8\n"}, - // Continuation comment alignment when a line with the starting comment is - // wrapped. - {"module foo(output logic very_very_very_very_long_name // A\n" - " // A.1\n" - "); endmodule\n", - "module foo (\n" - " output logic\n" - " very_very_very_very_long_name // A\n" - " // A.1\n" - ");\n" - "endmodule\n"}, - - // Attachment of ',' to elements in enum list (with and without comments) - {"typedef enum {\n" - " first , // c1\n" - " second\n" - "} e;\n", - "typedef enum {\n" - " first, // c1\n" - " second\n" - "} e;\n"}, - {"typedef enum {\n" - " first ,\n" - " // c1\n" - " second\n" - "} e;\n", - "typedef enum {\n" - " first,\n" - " // c1\n" - " second\n" - "} e;\n"}, - {"typedef enum {\n" - " first // c1\n" - " , second\n" - "} e;\n", - "typedef enum {\n" - " first // c1\n" - " , second\n" - "} e;\n"}, - {"typedef enum {\n" - " first\n" - " // c1\n" - " , second\n" - "} e;\n", - "typedef enum {\n" - " first\n" - " // c1\n" - " , second\n" - "} e;\n"}, - {"typedef enum {\n" - " first // c1\n" - " , // c2\n" - " second\n" - "} e;\n", - "typedef enum {\n" - " first // c1\n" - " , // c2\n" - " second\n" - "} e;\n"}, - {"typedef enum {\n" - " first\n" - " // c1\n" - " ,\n" - " // c2\n" - " second\n" - "} e;\n", - "typedef enum {\n" - " first\n" - " // c1\n" - " , // c2\n" - " second\n" - "} e;\n"}, - {"typedef enum {\n" - " first\n" - " // c1\n" - " , // c2\n" - " // c3\n" - " second\n" - "} e;\n", - "typedef enum {\n" - " first\n" - " // c1\n" - " , // c2\n" - " // c3\n" - " second\n" - "} e;\n"}, - {"typedef enum {\n" - " // c1\n" - " first\n" - " // c2\n" - " , // c3\n" - " // c4\n" - " second\n" - " // c5\n" - "} e;\n", - "typedef enum {\n" - " // c1\n" - " first\n" - " // c2\n" - " , // c3\n" - " // c4\n" - " second\n" - " // c5\n" - "} e;\n"}, - {"typedef enum {\n" - " // c1\n" - " // c1+\n" - " first // c2\n" - " // c2+\n" - " , // c3\n" - " // c3+\n" - " // c4\n" - " // c4+\n" - " second // c5\n" - " // c5+\n" - "} e;\n", - "typedef enum {\n" - " // c1\n" - " // c1+\n" - " first // c2\n" - " // c2+\n" - " , // c3\n" - " // c3+\n" - " // c4\n" - " // c4+\n" - " second // c5\n" - " // c5+\n" - "} e;\n"}, - {"typedef enum {\n" - " first , /* c1 */\n" - " second\n" - "} e;\n", - "typedef enum {\n" - " first, /* c1 */\n" - " second\n" - "} e;\n"}, - {"typedef enum {\n" - " first ,\n" - " /* c1 */\n" - " second\n" - "} e;\n", - "typedef enum {\n" - " first,\n" - " /* c1 */\n" - " second\n" - "} e;\n"}, - {"typedef enum {\n" - " first /* c1 */\n" - " , second\n" - "} e;\n", - "typedef enum {\n" - " first /* c1 */\n" - " , second\n" - "} e;\n"}, - {"typedef enum {\n" - " first\n" - " /* c1 */\n" - " , second\n" - "} e;\n", - "typedef enum {\n" - " first\n" - " /* c1 */\n" - " , second\n" - "} e;\n"}, - {"typedef enum {\n" - " first /* c1 */\n" - " , /* c2 */\n" - " second\n" - "} e;\n", - "typedef enum {\n" - " first /* c1 */\n" - " , /* c2 */\n" - " second\n" - "} e;\n"}, - {"typedef enum {\n" - " first\n" - " /* c1 */\n" - " ,\n" - " /* c2 */\n" - " second\n" - "} e;\n", - "typedef enum {\n" - " first\n" - " /* c1 */\n" - " ,\n" - " /* c2 */\n" - " second\n" - "} e;\n"}, - {"typedef enum {\n" - " /* c1 */\n" - " first\n" - " /* c2 */\n" - " , /* c3 */\n" - " /* c4 */\n" - " second\n" - " /* c5 */\n" - "} e;\n", - "typedef enum {\n" - " /* c1 */\n" - " first\n" - " /* c2 */\n" - " , /* c3 */\n" - " /* c4 */\n" - " second\n" - " /* c5 */\n" - "} e;\n"}, - {"typedef enum {\n" - " /* c1 */\n" - " /* c1+ */\n" - " first /* c2 */\n" - " /* c2+ */\n" - " , /* c3 */\n" - " /* c3+ */\n" - " /* c4 */\n" - " /* c4+ */\n" - " second /* c5 */\n" - " /* c5+ */\n" - "} e;\n", - "typedef enum {\n" - " /* c1 */\n" - " /* c1+ */\n" - " first /* c2 */\n" - " /* c2+ */\n" - " , /* c3 */\n" - " /* c3+ */\n" - " /* c4 */\n" - " /* c4+ */\n" - " second /* c5 */\n" - " /* c5+ */\n" - "} e;\n"}, - {"module m;\n" - "typedef enum {\n" - " first,\n" - " second\n" - "} // c\n" - "e;\n" - "endmodule\n", - "module m;\n" - " typedef enum {\n" - " first,\n" - " second\n" - " } // c\n" - " e;\n" - "endmodule\n"}, - // Attachment of ';' preceded by EOL comment - {"module m;\n" - "typedef enum {\n" - " first,\n" - " second\n" - "} e // c\n" - ";\n" - "endmodule\n", - "module m;\n" - " typedef enum {\n" - " first,\n" - " second\n" - " } e // c\n" - " ;\n" - "endmodule\n"}, - {"module m;\n" - "typedef enum {\n" - " first,\n" - " second\n" - "} // c1\n" - "e // c2\n" - ";\n" - "endmodule\n", - "module m;\n" - " typedef enum {\n" - " first,\n" - " second\n" - " } // c1\n" - " e // c2\n" - " ;\n" - "endmodule\n"}, - {"assign foo = bar\n" - "// comment\n" - ";\n", - "assign foo = bar\n" - " // comment\n" - " ;\n"}, - {"assign foo = bar // comment\n" - ";\n", - "assign foo = bar // comment\n" - ";\n"}, - - // Attachment of ',' to elements in PortActualList (with and without - // comments) - {"module foo;\n" - " bar foobar(\n" - " .first(1) // c1\n" - " ,\n" - " .second(2) // c2\n" - " );\n" - "endmodule\n", - "module foo;\n" - " bar foobar (\n" - " .first (1) // c1\n" - " , .second(2) // c2\n" - " );\n" - "endmodule\n"}, - {"module foo;\n" - " bar foobar(\n" - " .first(1) // c1\n" - " , .second(2) // c2\n" - " );\n" - "endmodule\n", - "module foo;\n" - " bar foobar (\n" - " .first (1) // c1\n" - " , .second(2) // c2\n" - " );\n" - "endmodule\n"}, - {"module foo;\n" - " bar foobar(\n" - " .first(1)\n" - " // c1\n" - " ,\n" - " .second(2)\n" - " // c2\n" - " );\n" - "endmodule\n", - "module foo;\n" - " bar foobar (\n" - " .first (1)\n" - " // c1\n" - " , .second(2)\n" - " // c2\n" - " );\n" - "endmodule\n"}, - {"module foo;\n" - " bar foobar(\n" - " .first(1)\n" - " // c1\n" - " , .second(2)\n" - " // c2\n" - " );\n" - "endmodule\n", - "module foo;\n" - " bar foobar (\n" - " .first (1)\n" - " // c1\n" - " , .second(2)\n" - " // c2\n" - " );\n" - "endmodule\n"}, - {"module foo;\n" - " bar foobar(\n" - " .first(1)\n" - " // c1\n" - " , // c2\n" - " .second(2)\n" - " // c3\n" - " );\n" - "endmodule\n", - "module foo;\n" - " bar foobar (\n" - " .first (1)\n" - " // c1\n" - " , // c2\n" - " .second(2)\n" - " // c3\n" - " );\n" - "endmodule\n"}, - {"module foo;\n" - " bar foobar(\n" - " // c1\n" - " // c1+\n" - " .first(1) // c2\n" - " // c2+\n" - " , // c3\n" - " // c3+\n" - " .second(2) // c4\n" - " // c4+\n" - " // c5\n" - " // c5+\n" - " );\n" - "endmodule\n", - "module foo;\n" - " bar foobar (\n" - " // c1\n" - " // c1+\n" - " .first (1) // c2\n" - " // c2+\n" - " , // c3\n" - " // c3+\n" - " .second(2) // c4\n" - " // c4+\n" - " // c5\n" - " // c5+\n" - " );\n" - "endmodule\n"}, - {"module foo;\n" - " bar foobar(\n" - " .first(1) /* c1 */\n" - " ,\n" - " .second(2) /* c2 */\n" - " );\n" - "endmodule\n", - "module foo;\n" - " bar foobar (\n" - " .first (1) /* c1 */\n" - " , .second(2) /* c2 */\n" - " );\n" - "endmodule\n"}, - {"module foo;\n" - " bar foobar(\n" - " /* c1 */ .first(1),\n" - " /* c2 */ .second(2)\n" - " );\n" - "endmodule\n", - "module foo;\n" - " bar foobar (\n" - " /* c1 */.first (1),\n" - " /* c2 */.second(2)\n" - " );\n" - "endmodule\n"}, - {"module foo;\n" - " bar foobar(\n" - " .first(1) /* c1 */\n" - " , .second(2) /* c2 */\n" - " );\n" - "endmodule\n", - "module foo;\n" - " bar foobar (\n" - " .first (1) /* c1 */\n" - " , .second(2) /* c2 */\n" - " );\n" - "endmodule\n"}, - {"module foo;\n" - " bar foobar(\n" - " /* c1 */.first(1)\n" - " /* c2 */, .second(2)\n" - " );\n" - "endmodule\n", - "module foo;\n" - " bar foobar (\n" - " /* c1 */ .first (1)\n" - " /* c2 */, .second(2)\n" - " );\n" - "endmodule\n"}, - {"module foo;\n" - " bar foobar(\n" - " .first(1)\n" - " /* c1 */\n" - " ,\n" - " .second(2)\n" - " /* c2 */\n" - " );\n" - "endmodule\n", - "module foo;\n" - " bar foobar (\n" - " .first (1)\n" - " /* c1 */\n" - " , .second(2)\n" - " /* c2 */\n" - " );\n" - "endmodule\n"}, - {"module foo;\n" - " bar foobar(\n" - " .first(1)\n" - " /* c1 */\n" - " , .second(2)\n" - " /* c2 */\n" - " );\n" - "endmodule\n", - "module foo;\n" - " bar foobar (\n" - " .first (1)\n" - " /* c1 */\n" - " , .second(2)\n" - " /* c2 */\n" - " );\n" - "endmodule\n"}, - {"module foo;\n" - " bar foobar(\n" - " .first(1)\n" - " /* c1 */\n" - " , /* c2 */\n" - " .second(2)\n" - " /* c3 */\n" - " );\n" - "endmodule\n", - "module foo;\n" - " bar foobar (\n" - " .first (1)\n" - " /* c1 */\n" - " , /* c2 */\n" - " .second(2)\n" - " /* c3 */\n" - " );\n" - "endmodule\n"}, - {"module foo;\n" - " bar foobar(\n" - " .first(1)\n" - " /* c1 */\n" - " , /* c2 */\n" - " .second(2)\n" - " /* c3 */\n" - " );\n" - "endmodule\n", - "module foo;\n" - " bar foobar (\n" - " .first (1)\n" - " /* c1 */\n" - " , /* c2 */\n" - " .second(2)\n" - " /* c3 */\n" - " );\n" - "endmodule\n"}, - {"module foo;\n" - " bar foobar(\n" - " /* c1 */\n" - " /* c1+ */\n" - " .first(1) /* c2 */\n" - " /* c2+ */\n" - " , /* c3 */\n" - " /* c3+ */\n" - " .second(2) /* c4 */\n" - " /* c4+ */\n" - " /* c5 */\n" - " /* c5+ */\n" - " );\n" - "endmodule\n", - "module foo;\n" - " bar foobar (\n" - " /* c1 */\n" - " /* c1+ */\n" - " .first (1) /* c2 */\n" - " /* c2+ */\n" - " , /* c3 */\n" - " /* c3+ */\n" - " .second(2) /* c4 */\n" - " /* c4+ */\n" - " /* c5 */\n" - " /* c5+ */\n" - " );\n" - "endmodule\n"}, - - // Attachment of ',' to elements in ActualNamedParameterList (with and - // without comments) - {"module foo;\n" - " bar#(\n" - " .first(1) // c1\n" - " ,\n" - " .second(2) // c2\n" - " ) baz ();\n" - "endmodule\n", - "module foo;\n" - " bar #(\n" - " .first (1) // c1\n" - " , .second(2) // c2\n" - " ) baz ();\n" - "endmodule\n"}, - {"module foo;\n" - " bar#(\n" - " .first(1) // c1\n" - " , .second(2) // c2\n" - " ) baz ();\n" - "endmodule\n", - "module foo;\n" - " bar #(\n" - " .first (1) // c1\n" - " , .second(2) // c2\n" - " ) baz ();\n" - "endmodule\n"}, - {"module foo;\n" - " bar#(\n" - " .first(1)\n" - " // c1\n" - " ,\n" - " .second(2)\n" - " // c2\n" - " ) baz ();\n" - "endmodule\n", - "module foo;\n" - " bar #(\n" - " .first (1)\n" - " // c1\n" - " , .second(2)\n" - " // c2\n" - " ) baz ();\n" - "endmodule\n"}, - {"module foo;\n" - " bar#(\n" - " .first(1)\n" - " // c1\n" - " , .second(2)\n" - " // c2\n" - " ) baz ();\n" - "endmodule\n", - "module foo;\n" - " bar #(\n" - " .first (1)\n" - " // c1\n" - " , .second(2)\n" - " // c2\n" - " ) baz ();\n" - "endmodule\n"}, - {"module foo;\n" - " bar#(\n" - " .first(1)\n" - " // c1\n" - " , // c2\n" - " .second(2)\n" - " // c3\n" - " ) baz ();\n" - "endmodule\n", - "module foo;\n" - " bar #(\n" - " .first (1)\n" - " // c1\n" - " , // c2\n" - " .second(2)\n" - " // c3\n" - " ) baz ();\n" - "endmodule\n"}, - {"module foo;\n" - " bar#(\n" - " // c1\n" - " // c1+\n" - " .first(1) // c2\n" - " // c2+\n" - " , // c3\n" - " // c3+\n" - " .second(2) // c4\n" - " // c4+\n" - " // c5\n" - " // c5+\n" - " ) baz ();\n" - "endmodule\n", - "module foo;\n" - " bar #(\n" - " // c1\n" - " // c1+\n" - " .first (1) // c2\n" - " // c2+\n" - " , // c3\n" - " // c3+\n" - " .second(2) // c4\n" - " // c4+\n" - " // c5\n" - " // c5+\n" - " ) baz ();\n" - "endmodule\n"}, - {"module foo;\n" - " bar#(\n" - " .first(1) /* c1 */\n" - " ,\n" - " .second(2) /* c2 */\n" - " ) baz ();\n" - "endmodule\n", - "module foo;\n" - " bar #(\n" - " .first (1) /* c1 */\n" - " , .second(2) /* c2 */\n" - " ) baz ();\n" - "endmodule\n"}, - {"module foo;\n" - " bar#(\n" - " /* c1 */ .first(1),\n" - " /* c2 */ .second(2)\n" - " ) baz ();\n" - "endmodule\n", - "module foo;\n" - " bar #(\n" - " /* c1 */.first (1),\n" - " /* c2 */.second(2)\n" - " ) baz ();\n" - "endmodule\n"}, - {"module foo;\n" - " bar#(\n" - " .first(1) /* c1 */\n" - " , .second(2) /* c2 */\n" - " ) baz ();\n" - "endmodule\n", - "module foo;\n" - " bar #(\n" - " .first (1) /* c1 */\n" - " , .second(2) /* c2 */\n" - " ) baz ();\n" - "endmodule\n"}, - {"module foo;\n" - " bar#(\n" - " /* c1 */.first(1)\n" - " /* c2 */, .second(2)\n" - " ) baz ();\n" - "endmodule\n", - "module foo;\n" - " bar #(\n" - " /* c1 */ .first (1)\n" - " /* c2 */, .second(2)\n" - " ) baz ();\n" - "endmodule\n"}, - {"module foo;\n" - " bar#(\n" - " .first(1)\n" - " /* c1 */\n" - " ,\n" - " .second(2)\n" - " /* c2 */\n" - " ) baz ();\n" - "endmodule\n", - "module foo;\n" - " bar #(\n" - " .first (1)\n" - " /* c1 */\n" - " , .second(2)\n" - " /* c2 */\n" - " ) baz ();\n" - "endmodule\n"}, - {"module foo;\n" - " bar#(\n" - " .first(1)\n" - " /* c1 */\n" - " , .second(2)\n" - " /* c2 */\n" - " ) baz ();\n" - "endmodule\n", - "module foo;\n" - " bar #(\n" - " .first (1)\n" - " /* c1 */\n" - " , .second(2)\n" - " /* c2 */\n" - " ) baz ();\n" - "endmodule\n"}, - {"module foo;\n" - " bar#(\n" - " .first(1)\n" - " /* c1 */\n" - " , /* c2 */\n" - " .second(2)\n" - " /* c3 */\n" - " ) baz ();\n" - "endmodule\n", - "module foo;\n" - " bar #(\n" - " .first (1)\n" - " /* c1 */\n" - " , /* c2 */\n" - " .second(2)\n" - " /* c3 */\n" - " ) baz ();\n" - "endmodule\n"}, - {"module foo;\n" - " bar#(\n" - " .first(1)\n" - " /* c1 */\n" - " , /* c2 */\n" - " .second(2)\n" - " /* c3 */\n" - " ) baz ();\n" - "endmodule\n", - "module foo;\n" - " bar #(\n" - " .first (1)\n" - " /* c1 */\n" - " , /* c2 */\n" - " .second(2)\n" - " /* c3 */\n" - " ) baz ();\n" - "endmodule\n"}, - {"module foo;\n" - " bar#(\n" - " /* c1 */\n" - " /* c1+ */\n" - " .first(1) /* c2 */\n" - " /* c2+ */\n" - " , /* c3 */\n" - " /* c3+ */\n" - " .second(2) /* c4 */\n" - " /* c4+ */\n" - " /* c5 */\n" - " /* c5+ */\n" - " ) baz ();\n" - "endmodule\n", - "module foo;\n" - " bar #(\n" - " /* c1 */\n" - " /* c1+ */\n" - " .first (1) /* c2 */\n" - " /* c2+ */\n" - " , /* c3 */\n" - " /* c3+ */\n" - " .second(2) /* c4 */\n" - " /* c4+ */\n" - " /* c5 */\n" - " /* c5+ */\n" - " ) baz ();\n" - "endmodule\n"}, - - // ":" and "'{" in a single line - {"assign foo[2] =\n" - "'{\n" - "bar: 1'b1, // c\n" - "baz: 1'b0, // c\n" - "foobar: CONSTANT,\n" - "qux:\n" - "{\n" - "a, // c\n" - "b\n" - "}\n" - "};\n", - "assign foo[2] = '{\n" - " bar: 1'b1, // c\n" - " baz: 1'b0, // c\n" - " foobar: CONSTANT,\n" - " qux: {\n" - " a, // c\n" - " b\n" - " }\n" - " };\n"}, - {"assign a = (b) ? '{c: d[e], f: '1} : g;\n", - "assign a = (b) ?\n" - " '{c: d[e], f: '1}\n" - " : g;\n"}, - - // ----------------------------------------------------------------- - // Comments around `else`. - // Check whether `else` partition is found correctly and that actual code is - // not appended to EOL comments. - - // generate if - - {"module zx;\n" - "if (x) assign z=y;\n" - "// eol-c\n" - "else if (r) assign z=w;\n" - "else assign x=y;\n" - "endmodule\n", - "module zx;\n" - " if (x) assign z = y;\n" - " // eol-c\n" - " else if (r) assign z = w;\n" - " else assign x = y;\n" - "endmodule\n"}, - {"module zx;\n" - "if (x) assign z=y;\n" - "// eol-c\n" - "// eol-c\n" - "else if (r) assign z=w;\n" - "else assign x=y;\n" - "endmodule\n", - "module zx;\n" - " if (x) assign z = y;\n" - " // eol-c\n" - " // eol-c\n" - " else if (r) assign z = w;\n" - " else assign x = y;\n" - "endmodule\n"}, - {"module zx;\n" - "if (x) assign z=y;\n" - "else // eol-c\n" - "if (r) assign z=w;\n" - "else assign x=y;\n" - "endmodule\n", - "module zx;\n" - " if (x) assign z = y;\n" - " else // eol-c\n" - " if (r) assign z = w;\n" - " else assign x = y;\n" - "endmodule\n"}, - {"module zx;\n" - "if (x) assign z=y;\n" - "else\n" - "// eol-c\n" - "if (r) assign z=w;\n" - "else assign x=y;\n" - "endmodule\n", - "module zx;\n" - " if (x) assign z = y;\n" - " else\n" - " // eol-c\n" - " if (r)\n" - " assign z = w;\n" - " else assign x = y;\n" - "endmodule\n"}, - {"module zx;\n" - "if (x) assign z=y;\n" - "// eol-c\n" - "else // eol-c\n" - "if (r) assign z=w;\n" - "else assign x=y;\n" - "endmodule\n", - "module zx;\n" - " if (x) assign z = y;\n" - " // eol-c\n" - " else // eol-c\n" - " if (r) assign z = w;\n" - " else assign x = y;\n" - "endmodule\n"}, - {"module zx;\n" - "if (x) assign z=y;\n" - "else // eol-c\n" - "// eol-c\n" - "if (r) assign z=w;\n" - "else assign x=y;\n" - "endmodule\n", - "module zx;\n" - " if (x) assign z = y;\n" - " else // eol-c\n" - " // eol-c\n" - " if (r)\n" - " assign z = w;\n" - " else assign x = y;\n" - "endmodule\n"}, - {"module zx;\n" - "if (x) assign z=y;\n" - "// eol-c\n" - "else // eol-c\n" - "// eol-c\n" - "if (r) assign z=w;\n" - "else assign x=y;\n" - "endmodule\n", - "module zx;\n" - " if (x) assign z = y;\n" - " // eol-c\n" - " else // eol-c\n" - " // eol-c\n" - " if (r)\n" - " assign z = w;\n" - " else assign x = y;\n" - "endmodule\n"}, - {"module zx;\n" - "if (x) assign z=y;\n" - "// eol-c\n" - "else // eol-c\n" - "// eol-c\n" - "if\n" - "// eol-c\n" - "(r) assign z=w;\n" - "else assign x=y;\n" - "endmodule\n", - "module zx;\n" - " if (x) assign z = y;\n" - " // eol-c\n" - " else // eol-c\n" - " // eol-c\n" - " if\n" - " // eol-c\n" - " (r)\n" - " assign z = w;\n" - " else assign x = y;\n" - "endmodule\n"}, - {"module zx;\n" - "if (x) assign z=y;\n" - "// eol-c\n" - "// eol-c\n" - "else // eol-c\n" - "// eol-c\n" - "// eol-c\n" - "if\n" - "// eol-c\n" - "// eol-c\n" - "(r) assign z=w;\n" - "else assign x=y;\n" - "endmodule\n", - "module zx;\n" - " if (x) assign z = y;\n" - " // eol-c\n" - " // eol-c\n" - " else // eol-c\n" - " // eol-c\n" - " // eol-c\n" - " if\n" - " // eol-c\n" - " // eol-c\n" - " (r)\n" - " assign z = w;\n" - " else assign x = y;\n" - "endmodule\n"}, - - // generate if with function call - - {"module zx;\n" - "if (x) assign z=y;\n" - "// eol-c\n" - "else if (foo(x) == bar(1, 2)) assign z=w;\n" - "else assign x=y;\n" - "endmodule\n", - "module zx;\n" - " if (x) assign z = y;\n" - " // eol-c\n" - " else if (foo(x) == bar(1, 2))\n" - " assign z = w;\n" - " else assign x = y;\n" - "endmodule\n"}, - {"module zx;\n" - "if (x) assign z=y;\n" - "// eol-c\n" - "// eol-c\n" - "else if (foo(x) == bar(1, 2)) assign z=w;\n" - "else assign x=y;\n" - "endmodule\n", - "module zx;\n" - " if (x) assign z = y;\n" - " // eol-c\n" - " // eol-c\n" - " else if (foo(x) == bar(1, 2))\n" - " assign z = w;\n" - " else assign x = y;\n" - "endmodule\n"}, - {"module zx;\n" - "if (x) assign z=y;\n" - "else // eol-c\n" - "if (foo(x) == bar(1, 2)) assign z=w;\n" - "else assign x=y;\n" - "endmodule\n", - "module zx;\n" - " if (x) assign z = y;\n" - " else // eol-c\n" - " if (foo(x) == bar(1, 2)) assign z = w;\n" - " else assign x = y;\n" - "endmodule\n"}, - {"module zx;\n" - "if (x) assign z=y;\n" - "else\n" - "// eol-c\n" - "if (foo(x) == bar(1, 2)) assign z=w;\n" - "else assign x=y;\n" - "endmodule\n", - "module zx;\n" - " if (x) assign z = y;\n" - " else\n" - " // eol-c\n" - " if (foo(\n" - " x\n" - " ) == bar(\n" - " 1, 2\n" - " ))\n" - " assign z = w;\n" - " else assign x = y;\n" - "endmodule\n"}, - {"module zx;\n" - "if (x) assign z=y;\n" - "// eol-c\n" - "else // eol-c\n" - "if (foo(x) == bar(1, 2)) assign z=w;\n" - "else assign x=y;\n" - "endmodule\n", - "module zx;\n" - " if (x) assign z = y;\n" - " // eol-c\n" - " else // eol-c\n" - " if (foo(x) == bar(1, 2)) assign z = w;\n" - " else assign x = y;\n" - "endmodule\n"}, - {"module zx;\n" - "if (x) assign z=y;\n" - "else // eol-c\n" - "// eol-c\n" - "if (foo(x) == bar(1, 2)) assign z=w;\n" - "else assign x=y;\n" - "endmodule\n", - "module zx;\n" - " if (x) assign z = y;\n" - " else // eol-c\n" - " // eol-c\n" - " if (foo(\n" - " x\n" - " ) == bar(\n" - " 1, 2\n" - " ))\n" - " assign z = w;\n" - " else assign x = y;\n" - "endmodule\n"}, - {"module zx;\n" - "if (x) assign z=y;\n" - "// eol-c\n" - "else // eol-c\n" - "// eol-c\n" - "if (foo(x) == bar(1, 2)) assign z=w;\n" - "else assign x=y;\n" - "endmodule\n", - "module zx;\n" - " if (x) assign z = y;\n" - " // eol-c\n" - " else // eol-c\n" - " // eol-c\n" - " if (foo(\n" - " x\n" - " ) == bar(\n" - " 1, 2\n" - " ))\n" - " assign z = w;\n" - " else assign x = y;\n" - "endmodule\n"}, - {"module zx;\n" - "if (x) assign z=y;\n" - "// eol-c\n" - "else // eol-c\n" - "// eol-c\n" - "if\n" - "// eol-c\n" - "(foo(x) == bar(1, 2)) assign z=w;\n" - "else assign x=y;\n" - "endmodule\n", - "module zx;\n" - " if (x) assign z = y;\n" - " // eol-c\n" - " else // eol-c\n" - " // eol-c\n" - " if\n" - " // eol-c\n" - " (foo(\n" - " x\n" - " ) == bar(\n" - " 1, 2\n" - " ))\n" - " assign z = w;\n" - " else assign x = y;\n" - "endmodule\n"}, - {"module zx;\n" - "if (x) assign z=y;\n" - "// eol-c\n" - "// eol-c\n" - "else // eol-c\n" - "// eol-c\n" - "// eol-c\n" - "if\n" - "// eol-c\n" - "// eol-c\n" - "(foo(x) == bar(1, 2)) assign z=w;\n" - "else assign x=y;\n" - "endmodule\n", - "module zx;\n" - " if (x) assign z = y;\n" - " // eol-c\n" - " // eol-c\n" - " else // eol-c\n" - " // eol-c\n" - " // eol-c\n" - " if\n" - " // eol-c\n" - " // eol-c\n" - " (foo(\n" - " x\n" - " ) == bar(\n" - " 1, 2\n" - " ))\n" - " assign z = w;\n" - " else assign x = y;\n" - "endmodule\n"}, - - // else begin - - {"module zx;\n" - "always begin\n" - "if (a) b<=1;\n" - "// eol-c\n" - "else begin b<=2;\n" - "end\n" - "end\n" - "endmodule\n", - "module zx;\n" - " always begin\n" - " if (a) b <= 1;\n" - " // eol-c\n" - " else begin\n" - " b <= 2;\n" - " end\n" - " end\n" - "endmodule\n"}, - {"module zx;\n" - "always begin\n" - "if (a) b<=1;\n" - "// eol-c\n" - "// eol-c\n" - "else begin b<=2;\n" - "end\n" - "end\n" - "endmodule\n", - "module zx;\n" - " always begin\n" - " if (a) b <= 1;\n" - " // eol-c\n" - " // eol-c\n" - " else begin\n" - " b <= 2;\n" - " end\n" - " end\n" - "endmodule\n"}, - {"module zx;\n" - "always begin\n" - "if (a) b<=1;\n" - "else // eol-c\n" - "begin b<=2;\n" - "end\n" - "end\n" - "endmodule\n", - "module zx;\n" - " always begin\n" - " if (a) b <= 1;\n" - " else // eol-c\n" - " begin\n" - " b <= 2;\n" - " end\n" - " end\n" - "endmodule\n"}, - {"module zx;\n" - "always begin\n" - "if (a) b<=1;\n" - "else\n" - "// eol-c\n" - "begin b<=2;\n" - "end\n" - "end\n" - "endmodule\n", - "module zx;\n" - " always begin\n" - " if (a) b <= 1;\n" - " else\n" - " // eol-c\n" - " begin\n" - " b <= 2;\n" - " end\n" - " end\n" - "endmodule\n"}, - {"module zx;\n" - "always begin\n" - "if (a) b<=1;\n" - "// eol-c\n" - "else // eol-c\n" - "begin b<=2;\n" - "end\n" - "end\n" - "endmodule\n", - "module zx;\n" - " always begin\n" - " if (a) b <= 1;\n" - " // eol-c\n" - " else // eol-c\n" - " begin\n" - " b <= 2;\n" - " end\n" - " end\n" - "endmodule\n"}, - {"module zx;\n" - "always begin\n" - "if (a) b<=1;\n" - "else // eol-c\n" - "// eol-c\n" - "begin b<=2;\n" - "end\n" - "end\n" - "endmodule\n", - "module zx;\n" - " always begin\n" - " if (a) b <= 1;\n" - " else // eol-c\n" - " // eol-c\n" - " begin\n" - " b <= 2;\n" - " end\n" - " end\n" - "endmodule\n"}, - - // else if - - {"module zx;\n" - "always @(clr or set)\n" - "if (clr) assign q=0;\n" - "// eol-c\n" - "else if (set) assign q=1;\n" - "else deassign q;\n" - "endmodule\n", - "module zx;\n" - " always @(clr or set)\n" - " if (clr) assign q = 0;\n" - " // eol-c\n" - " else if (set) assign q = 1;\n" - " else deassign q;\n" - "endmodule\n"}, - {"module zx;\n" - "always @(clr or set)\n" - "if (clr) assign q=0;\n" - "// eol-c\n" - "// eol-c\n" - "else if (set) assign q=1;\n" - "else deassign q;\n" - "endmodule\n", - "module zx;\n" - " always @(clr or set)\n" - " if (clr) assign q = 0;\n" - " // eol-c\n" - " // eol-c\n" - " else if (set) assign q = 1;\n" - " else deassign q;\n" - "endmodule\n"}, - {"module zx;\n" - "always @(clr or set)\n" - "if (clr) assign q=0;\n" - "else // eol-c\n" - "if (set) assign q=1;\n" - "else deassign q;\n" - "endmodule\n", - "module zx;\n" - " always @(clr or set)\n" - " if (clr) assign q = 0;\n" - " else // eol-c\n" - " if (set) assign q = 1;\n" - " else deassign q;\n" - "endmodule\n"}, - {"module zx;\n" - "always @(clr or set)\n" - "if (clr) assign q=0;\n" - "else\n" - "// eol-c\n" - "if (set) assign q=1;\n" - "else deassign q;\n" - "endmodule\n", - "module zx;\n" - " always @(clr or set)\n" - " if (clr) assign q = 0;\n" - " else\n" - " // eol-c\n" - " if (set)\n" - " assign q = 1;\n" - " else deassign q;\n" - "endmodule\n"}, - {"module zx;\n" - "always @(clr or set)\n" - "if (clr) assign q=0;\n" - "// eol-c\n" - "else // eol-c\n" - "if (set) assign q=1;\n" - "else deassign q;\n" - "endmodule\n", - "module zx;\n" - " always @(clr or set)\n" - " if (clr) assign q = 0;\n" - " // eol-c\n" - " else // eol-c\n" - " if (set) assign q = 1;\n" - " else deassign q;\n" - "endmodule\n"}, - {"module zx;\n" - "always @(clr or set)\n" - "if (clr) assign q=0;\n" - "else // eol-c\n" - "// eol-c\n" - "if (set) assign q=1;\n" - "else deassign q;\n" - "endmodule\n", - "module zx;\n" - " always @(clr or set)\n" - " if (clr) assign q = 0;\n" - " else // eol-c\n" - " // eol-c\n" - " if (set)\n" - " assign q = 1;\n" - " else deassign q;\n" - "endmodule\n"}, - {"module zx;\n" - "always @(clr or set)\n" - "if (clr) assign q=0;\n" - "// eol-c\n" - "else // eol-c\n" - "// eol-c\n" - "if (set) assign q=1;\n" - "else deassign q;\n" - "endmodule\n", - "module zx;\n" - " always @(clr or set)\n" - " if (clr) assign q = 0;\n" - " // eol-c\n" - " else // eol-c\n" - " // eol-c\n" - " if (set)\n" - " assign q = 1;\n" - " else deassign q;\n" - "endmodule\n"}, - {"module zx;\n" - "always @(clr or set)\n" - "if (clr) assign q=0;\n" - "// eol-c\n" - "else // eol-c\n" - "// eol-c\n" - "if\n" - "// eol-c\n" - "(set) assign q=1;\n" - "else deassign q;\n" - "endmodule\n", - "module zx;\n" - " always @(clr or set)\n" - " if (clr) assign q = 0;\n" - " // eol-c\n" - " else // eol-c\n" - " // eol-c\n" - " if\n" - " // eol-c\n" - " (set)\n" - " assign q = 1;\n" - " else deassign q;\n" - "endmodule\n"}, - {"module zx;\n" - "always @(clr or set)\n" - "if (clr) assign q=0;\n" - "// eol-c\n" - "// eol-c\n" - "else // eol-c\n" - "// eol-c\n" - "// eol-c\n" - "if\n" - "// eol-c\n" - "// eol-c\n" - "(set) assign q=1;\n" - "else deassign q;\n" - "endmodule\n", - "module zx;\n" - " always @(clr or set)\n" - " if (clr) assign q = 0;\n" - " // eol-c\n" - " // eol-c\n" - " else // eol-c\n" - " // eol-c\n" - " // eol-c\n" - " if\n" - " // eol-c\n" - " // eol-c\n" - " (set)\n" - " assign q = 1;\n" - " else deassign q;\n" - "endmodule\n"}, - - // else if with function call - - {"module zx;\n" - "always @(clr or set)\n" - "if (clr) assign q=0;\n" - "// eol-c\n" - "else if (foo(clr, set, 1)) assign q=1;\n" - "else deassign q;\n" - "endmodule\n", - "module zx;\n" - " always @(clr or set)\n" - " if (clr) assign q = 0;\n" - " // eol-c\n" - " else if (foo(clr, set, 1))\n" - " assign q = 1;\n" - " else deassign q;\n" - "endmodule\n"}, - {"module zx;\n" - "always @(clr or set)\n" - "if (clr) assign q=0;\n" - "// eol-c\n" - "// eol-c\n" - "else if (foo(clr, set, 1)) assign q=1;\n" - "else deassign q;\n" - "endmodule\n", - "module zx;\n" - " always @(clr or set)\n" - " if (clr) assign q = 0;\n" - " // eol-c\n" - " // eol-c\n" - " else if (foo(clr, set, 1))\n" - " assign q = 1;\n" - " else deassign q;\n" - "endmodule\n"}, - {"module zx;\n" - "always @(clr or set)\n" - "if (clr) assign q=0;\n" - "else // eol-c\n" - "if (foo(clr, set, 1)) assign q=1;\n" - "else deassign q;\n" - "endmodule\n", - "module zx;\n" - " always @(clr or set)\n" - " if (clr) assign q = 0;\n" - " else // eol-c\n" - " if (foo(clr, set, 1)) assign q = 1;\n" - " else deassign q;\n" - "endmodule\n"}, - {"module zx;\n" - "always @(clr or set)\n" - "if (clr) assign q=0;\n" - "else\n" - "// eol-c\n" - "if (foo(clr, set, 1)) assign q=1;\n" - "else deassign q;\n" - "endmodule\n", - "module zx;\n" - " always @(clr or set)\n" - " if (clr) assign q = 0;\n" - " else\n" - " // eol-c\n" - " if (foo(\n" - " clr, set, 1\n" - " ))\n" - " assign q = 1;\n" - " else deassign q;\n" - "endmodule\n"}, - {"module zx;\n" - "always @(clr or set)\n" - "if (clr) assign q=0;\n" - "// eol-c\n" - "else // eol-c\n" - "if (foo(clr, set, 1)) assign q=1;\n" - "else deassign q;\n" - "endmodule\n", - "module zx;\n" - " always @(clr or set)\n" - " if (clr) assign q = 0;\n" - " // eol-c\n" - " else // eol-c\n" - " if (foo(clr, set, 1)) assign q = 1;\n" - " else deassign q;\n" - "endmodule\n"}, - {"module zx;\n" - "always @(clr or set)\n" - "if (clr) assign q=0;\n" - "else // eol-c\n" - "// eol-c\n" - "if (foo(clr, set, 1)) assign q=1;\n" - "else deassign q;\n" - "endmodule\n", - "module zx;\n" - " always @(clr or set)\n" - " if (clr) assign q = 0;\n" - " else // eol-c\n" - " // eol-c\n" - " if (foo(\n" - " clr, set, 1\n" - " ))\n" - " assign q = 1;\n" - " else deassign q;\n" - "endmodule\n"}, - {"module zx;\n" - "always @(clr or set)\n" - "if (clr) assign q=0;\n" - "// eol-c\n" - "else // eol-c\n" - "// eol-c\n" - "if (foo(clr, set, 1)) assign q=1;\n" - "else deassign q;\n" - "endmodule\n", - "module zx;\n" - " always @(clr or set)\n" - " if (clr) assign q = 0;\n" - " // eol-c\n" - " else // eol-c\n" - " // eol-c\n" - " if (foo(\n" - " clr, set, 1\n" - " ))\n" - " assign q = 1;\n" - " else deassign q;\n" - "endmodule\n"}, - {"module zx;\n" - "always @(clr or set)\n" - "if (clr) assign q=0;\n" - "// eol-c\n" - "else // eol-c\n" - "// eol-c\n" - "if\n" - "// eol-c\n" - "(foo(clr, set, 1)) assign q=1;\n" - "else deassign q;\n" - "endmodule\n", - "module zx;\n" - " always @(clr or set)\n" - " if (clr) assign q = 0;\n" - " // eol-c\n" - " else // eol-c\n" - " // eol-c\n" - " if\n" - " // eol-c\n" - " (foo(\n" - " clr, set, 1\n" - " ))\n" - " assign q = 1;\n" - " else deassign q;\n" - "endmodule\n"}, - {"module zx;\n" - "always @(clr or set)\n" - "if (clr) assign q=0;\n" - "// eol-c\n" - "// eol-c\n" - "else // eol-c\n" - "// eol-c\n" - "// eol-c\n" - "if\n" - "// eol-c\n" - "// eol-c\n" - "(foo(clr, set, 1)) assign q=1;\n" - "else deassign q;\n" - "endmodule\n", - "module zx;\n" - " always @(clr or set)\n" - " if (clr) assign q = 0;\n" - " // eol-c\n" - " // eol-c\n" - " else // eol-c\n" - " // eol-c\n" - " // eol-c\n" - " if\n" - " // eol-c\n" - " // eol-c\n" - " (foo(\n" - " clr, set, 1\n" - " ))\n" - " assign q = 1;\n" - " else deassign q;\n" - "endmodule\n"}, - - // ----------------------------------------------------------------- - // Comments around and inside macro calls. - - // between identifier and '(', no args - - {"// verilog_syntax: parse-as-module-body", - "// verilog_syntax: parse-as-module-body\n"}, - {"// verilog_syntax: parse-as-statements", - "// verilog_syntax: parse-as-statements\n"}, - {"// verilog_syntax: parse-as-class-body", - "// verilog_syntax: parse-as-class-body\n"}, - {"// verilog_syntax: parse-as-package-body", - "// verilog_syntax: parse-as-package-body\n"}, - {"// verilog_syntax: parse-as-library-map", - "// verilog_syntax: parse-as-library-map\n"}, - {"// verilog_syntax: does-not-exist-mode", - "// verilog_syntax: does-not-exist-mode\n"}, - {"// verilog_syntax: parse-as-module-body\n", - "// verilog_syntax: parse-as-module-body\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "// comment", - "// verilog_syntax: parse-as-module-body\n" - "// comment\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz /* c */ ();\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz /* c */ ();\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz /* c1 */ /* c2 */ ();\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz /* c1 */ /* c2 */ ();\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz /* c */\n" - "();\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz /* c */\n" - " ();\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz /* c1 */ /* c2 */\n" - "();\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz /* c1 */ /* c2 */\n" - " ();\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz // c\n" - "();\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz // c\n" - " ();\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz /* c1 */ // c2\n" - "();\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz /* c1 */ // c2\n" - " ();\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz\n" - "/* c */ ();\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz\n" - " /* c */ ();\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz\n" - "/* c1 */ /* c2 */ ();\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz\n" - " /* c1 */ /* c2 */ ();\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz\n" - "/* c */\n" - "();\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz\n" - " /* c */\n" - " ();\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz\n" - "/* c1 */ /* c2 */\n" - "();\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz\n" - " /* c1 */ /* c2 */\n" - " ();\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz\n" - "// c\n" - "();\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz\n" - " // c\n" - " ();\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz\n" - "/* c1 */ // c2\n" - "();\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz\n" - " /* c1 */ // c2\n" - " ();\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz\n" - "/* c1 */\n" - "/* c2 */\n" - "();\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz\n" - " /* c1 */\n" - " /* c2 */\n" - " ();\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz\n" - "// c1\n" - "// c2\n" - "();\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz\n" - " // c1\n" - " // c2\n" - " ();\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz /* c1 */\n" - "/* c2 */ ();\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz /* c1 */\n" - " /* c2 */ ();\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz // c1\n" - "/* c2 */ ();\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz // c1\n" - " /* c2 */ ();\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz /* c1 */\n" - "/* c2 */\n" - "/* c3 */ ();\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz /* c1 */\n" - " /* c2 */\n" - " /* c3 */ ();\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz /* c1 */\n" - "/* c2 */\n" - "();\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz /* c1 */\n" - " /* c2 */\n" - " ();\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz // c1\n" - "/* c2 */\n" - "();\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz // c1\n" - " /* c2 */\n" - " ();\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz /* c1 */\n" - "// c2\n" - "();\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz /* c1 */\n" - " // c2\n" - " ();\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz // c1\n" - "// c2\n" - "();\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz // c1\n" - " // c2\n" - " ();\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz /* c1 */\n" - "/* c2 */\n" - "/* c3 */\n" - "();\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz /* c1 */\n" - " /* c2 */\n" - " /* c3 */\n" - " ();\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz // c1\n" - "// c2\n" - "// c3\n" - "();\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz // c1\n" - " // c2\n" - " // c3\n" - " ();\n"}, - - // between identifier and '(', with arg - - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz /* c */ (arg);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz /* c */ (arg);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz /* c1 */ /* c2 */ (arg);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz /* c1 */ /* c2 */ (arg);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz /* c */\n" - "(arg);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz /* c */\n" - " (arg);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz /* c1 */ /* c2 */\n" - "(arg);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz /* c1 */ /* c2 */\n" - " (arg);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz // c\n" - "(arg);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz // c\n" - " (arg);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz /* c1 */ // c2\n" - "(arg);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz /* c1 */ // c2\n" - " (arg);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz\n" - "/* c */ (arg);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz\n" - " /* c */ (arg);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz\n" - "/* c1 */ /* c2 */ (arg);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz\n" - " /* c1 */ /* c2 */ (arg);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz\n" - "/* c */\n" - "(arg);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz\n" - " /* c */\n" - " (arg);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz\n" - "/* c1 */ /* c2 */\n" - "(arg);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz\n" - " /* c1 */ /* c2 */\n" - " (arg);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz\n" - "// c\n" - "(arg);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz\n" - " // c\n" - " (arg);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz\n" - "/* c1 */ // c2\n" - "(arg);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz\n" - " /* c1 */ // c2\n" - " (arg);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz\n" - "/* c1 */\n" - "/* c2 */\n" - "(arg);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz\n" - " /* c1 */\n" - " /* c2 */\n" - " (arg);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz\n" - "// c1\n" - "// c2\n" - "(arg);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz\n" - " // c1\n" - " // c2\n" - " (arg);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz /* c1 */\n" - "/* c2 */ (arg);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz /* c1 */\n" - " /* c2 */ (arg);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz // c1\n" - "/* c2 */ (arg);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz // c1\n" - " /* c2 */ (arg);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz /* c1 */\n" - "/* c2 */\n" - "/* c3 */ (arg);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz /* c1 */\n" - " /* c2 */\n" - " /* c3 */ (arg);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz /* c1 */\n" - "/* c2 */\n" - "(arg);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz /* c1 */\n" - " /* c2 */\n" - " (arg);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz // c1\n" - "/* c2 */\n" - "(arg);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz // c1\n" - " /* c2 */\n" - " (arg);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz /* c1 */\n" - "// c2\n" - "(arg);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz /* c1 */\n" - " // c2\n" - " (arg);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz // c1\n" - "// c2\n" - "(arg);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz // c1\n" - " // c2\n" - " (arg);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz /* c1 */\n" - "/* c2 */\n" - "/* c3 */\n" - "(arg);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz /* c1 */\n" - " /* c2 */\n" - " /* c3 */\n" - " (arg);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz // c1\n" - "// c2\n" - "// c3\n" - "(arg);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz // c1\n" - " // c2\n" - " // c3\n" - " (arg);\n"}, - - // after '(', no args - - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(/* c */);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz( /* c */);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(/* c1 */ /* c2 */);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz( /* c1 */ /* c2 */);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(/* c */\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz( /* c */\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(/* c1 */ /* c2 */\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz( /* c1 */ /* c2 */\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(// c\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz( // c\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(/* c1 */ // c2\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz( /* c1 */ // c2\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(\n" - "/* c */);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(\n" - "/* c */);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(\n" - "/* c1 */ /* c2 */);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(\n" - "/* c1 */ /* c2 */);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(\n" - "/* c */\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(\n" - " /* c */\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(\n" - "/* c1 */ /* c2 */\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(\n" - " /* c1 */ /* c2 */\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(\n" - "// c\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(\n" - " // c\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(\n" - "/* c1 */ // c2\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(\n" - " /* c1 */ // c2\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(\n" - "/* c1 */\n" - "/* c2 */\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(\n" - " /* c1 */\n" - " /* c2 */\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(\n" - "// c1\n" - "// c2\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(\n" - " // c1\n" - " // c2\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(/* c1 */\n" - "/* c2 */);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz( /* c1 */\n" - "/* c2 */);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(// c1\n" - "/* c2 */);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz( // c1\n" - "/* c2 */);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(/* c1 */\n" - "/* c2 */\n" - "/* c3 */);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz( /* c1 */\n" - " /* c2 */\n" - "/* c3 */);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(/* c1 */\n" - "/* c2 */\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz( /* c1 */\n" - " /* c2 */\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(// c1\n" - "/* c2 */\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz( // c1\n" - " /* c2 */\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(/* c1 */\n" - "// c2\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz( /* c1 */\n" - " // c2\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(// c1\n" - "// c2\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz( // c1\n" - " // c2\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(/* c1 */\n" - "/* c2 */\n" - "/* c3 */\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz( /* c1 */\n" - " /* c2 */\n" - " /* c3 */\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(// c1\n" - "// c2\n" - "// c3\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz( // c1\n" - " // c2\n" - " // c3\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(/* c */);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ( /* c */);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(/* c1 */ /* c2 */);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ( /* c1 */ /* c2 */);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(/* c */\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ( /* c */\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(/* c1 */ /* c2 */\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ( /* c1 */ /* c2 */\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(// c\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ( // c\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(/* c1 */ // c2\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ( /* c1 */ // c2\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(\n" - "/* c */);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(\n" - "/* c */);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(\n" - "/* c1 */ /* c2 */);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(\n" - "/* c1 */ /* c2 */);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(\n" - "/* c */\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(\n" - " /* c */\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(\n" - "/* c1 */ /* c2 */\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(\n" - " /* c1 */ /* c2 */\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(\n" - "// c\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(\n" - " // c\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(\n" - "/* c1 */ // c2\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(\n" - " /* c1 */ // c2\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(\n" - "/* c1 */\n" - "/* c2 */\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(\n" - " /* c1 */\n" - " /* c2 */\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(\n" - "// c1\n" - "// c2\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(\n" - " // c1\n" - " // c2\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(/* c1 */\n" - "/* c2 */);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ( /* c1 */\n" - "/* c2 */);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(// c1\n" - "/* c2 */);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ( // c1\n" - "/* c2 */);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(/* c1 */\n" - "/* c2 */\n" - "/* c3 */);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ( /* c1 */\n" - " /* c2 */\n" - "/* c3 */);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(/* c1 */\n" - "/* c2 */\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ( /* c1 */\n" - " /* c2 */\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(// c1\n" - "/* c2 */\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ( // c1\n" - " /* c2 */\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(/* c1 */\n" - "// c2\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ( /* c1 */\n" - " // c2\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(// c1\n" - "// c2\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ( // c1\n" - " // c2\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(/* c1 */\n" - "/* c2 */\n" - "/* c3 */\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ( /* c1 */\n" - " /* c2 */\n" - " /* c3 */\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(// c1\n" - "// c2\n" - "// c3\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ( // c1\n" - " // c2\n" - " // c3\n" - ");\n"}, - - // after '(', with arg - - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(/* c */arg);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz( /* c */ arg);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(/* c1 */ /* c2 */arg);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz( /* c1 */ /* c2 */ arg);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(/* c */\n" - "arg);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz( /* c */\n" - " arg);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(/* c1 */ /* c2 */\n" - "arg);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz( /* c1 */ /* c2 */\n" - " arg);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(// c\n" - "arg);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz( // c\n" - " arg);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(/* c1 */ // c2\n" - "arg);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz( /* c1 */ // c2\n" - " arg);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(\n" - "/* c */arg);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(\n" - " /* c */ arg);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(\n" - "/* c1 */ /* c2 */arg);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(\n" - " /* c1 */ /* c2 */ arg);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(\n" - "/* c */\n" - "arg);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(\n" - " /* c */\n" - " arg);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(\n" - "/* c1 */ /* c2 */\n" - "arg);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(\n" - " /* c1 */ /* c2 */\n" - " arg);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(\n" - "// c\n" - "arg);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(\n" - " // c\n" - " arg);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(\n" - "/* c1 */ // c2\n" - "arg);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(\n" - " /* c1 */ // c2\n" - " arg);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(\n" - "/* c1 */\n" - "/* c2 */\n" - "arg);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(\n" - " /* c1 */\n" - " /* c2 */\n" - " arg);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(\n" - "// c1\n" - "// c2\n" - "arg);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(\n" - " // c1\n" - " // c2\n" - " arg);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(/* c1 */\n" - "/* c2 */arg);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz( /* c1 */\n" - " /* c2 */ arg);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(// c1\n" - "/* c2 */arg);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz( // c1\n" - " /* c2 */ arg);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(/* c1 */\n" - "/* c2 */\n" - "/* c3 */arg);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz( /* c1 */\n" - " /* c2 */\n" - " /* c3 */ arg);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(/* c1 */\n" - "/* c2 */\n" - "arg);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz( /* c1 */\n" - " /* c2 */\n" - " arg);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(// c1\n" - "/* c2 */\n" - "arg);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz( // c1\n" - " /* c2 */\n" - " arg);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(/* c1 */\n" - "// c2\n" - "arg);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz( /* c1 */\n" - " // c2\n" - " arg);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(// c1\n" - "// c2\n" - "arg);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz( // c1\n" - " // c2\n" - " arg);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(/* c1 */\n" - "/* c2 */\n" - "/* c3 */\n" - "arg);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz( /* c1 */\n" - " /* c2 */\n" - " /* c3 */\n" - " arg);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(// c1\n" - "// c2\n" - "// c3\n" - "arg);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz( // c1\n" - " // c2\n" - " // c3\n" - " arg);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(/* c */arg);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ( /* c */ arg);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(/* c1 */ /* c2 */arg);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ( /* c1 */ /* c2 */ arg);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(/* c */\n" - "arg);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ( /* c */\n" - " arg);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(/* c1 */ /* c2 */\n" - "arg);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ( /* c1 */ /* c2 */\n" - " arg);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(// c\n" - "arg);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ( // c\n" - " arg);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(/* c1 */ // c2\n" - "arg);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ( /* c1 */ // c2\n" - " arg);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(\n" - "/* c */arg);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(\n" - " /* c */ arg);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(\n" - "/* c1 */ /* c2 */arg);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(\n" - " /* c1 */ /* c2 */ arg);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(\n" - "/* c */\n" - "arg);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(\n" - " /* c */\n" - " arg);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(\n" - "/* c1 */ /* c2 */\n" - "arg);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(\n" - " /* c1 */ /* c2 */\n" - " arg);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(\n" - "// c\n" - "arg);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(\n" - " // c\n" - " arg);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(\n" - "/* c1 */ // c2\n" - "arg);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(\n" - " /* c1 */ // c2\n" - " arg);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(\n" - "/* c1 */\n" - "/* c2 */\n" - "arg);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(\n" - " /* c1 */\n" - " /* c2 */\n" - " arg);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(\n" - "// c1\n" - "// c2\n" - "arg);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(\n" - " // c1\n" - " // c2\n" - " arg);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(/* c1 */\n" - "/* c2 */arg);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ( /* c1 */\n" - " /* c2 */ arg);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(// c1\n" - "/* c2 */arg);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ( // c1\n" - " /* c2 */ arg);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(/* c1 */\n" - "/* c2 */\n" - "/* c3 */arg);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ( /* c1 */\n" - " /* c2 */\n" - " /* c3 */ arg);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(/* c1 */\n" - "/* c2 */\n" - "arg);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ( /* c1 */\n" - " /* c2 */\n" - " arg);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(// c1\n" - "/* c2 */\n" - "arg);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ( // c1\n" - " /* c2 */\n" - " arg);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(/* c1 */\n" - "// c2\n" - "arg);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ( /* c1 */\n" - " // c2\n" - " arg);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(// c1\n" - "// c2\n" - "arg);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ( // c1\n" - " // c2\n" - " arg);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(/* c1 */\n" - "/* c2 */\n" - "/* c3 */\n" - "arg);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ( /* c1 */\n" - " /* c2 */\n" - " /* c3 */\n" - " arg);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(// c1\n" - "// c2\n" - "// c3\n" - "arg);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ( // c1\n" - " // c2\n" - " // c3\n" - " arg);\n"}, - - // after single arg - - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg/* c */);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg /* c */);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg/* c1 */ /* c2 */);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg /* c1 */ /* c2 */);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg/* c */\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg /* c */\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg/* c1 */ /* c2 */\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg /* c1 */ /* c2 */\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg// c\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg // c\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg/* c1 */ // c2\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg /* c1 */ // c2\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg\n" - "/* c */);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg\n" - "/* c */);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg\n" - "/* c1 */ /* c2 */);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg\n" - "/* c1 */ /* c2 */);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg\n" - "/* c */\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg\n" - " /* c */\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg\n" - "/* c1 */ /* c2 */\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg\n" - " /* c1 */ /* c2 */\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg\n" - "// c\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg\n" - " // c\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg\n" - "/* c1 */ // c2\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg\n" - " /* c1 */ // c2\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg\n" - "/* c1 */\n" - "/* c2 */\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg\n" - " /* c1 */\n" - " /* c2 */\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg\n" - "// c1\n" - "// c2\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg\n" - " // c1\n" - " // c2\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg/* c1 */\n" - "/* c2 */);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg /* c1 */\n" - "/* c2 */);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg// c1\n" - "/* c2 */);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg // c1\n" - "/* c2 */);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg/* c1 */\n" - "/* c2 */\n" - "/* c3 */);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg /* c1 */\n" - " /* c2 */\n" - "/* c3 */);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg/* c1 */\n" - "/* c2 */\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg /* c1 */\n" - " /* c2 */\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg// c1\n" - "/* c2 */\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg // c1\n" - " /* c2 */\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg/* c1 */\n" - "// c2\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg /* c1 */\n" - " // c2\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg// c1\n" - "// c2\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg // c1\n" - " // c2\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg/* c1 */\n" - "/* c2 */\n" - "/* c3 */\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg /* c1 */\n" - " /* c2 */\n" - " /* c3 */\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg// c1\n" - "// c2\n" - "// c3\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg // c1\n" - " // c2\n" - " // c3\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg/* c */);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg /* c */);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg/* c1 */ /* c2 */);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg /* c1 */ /* c2 */);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg/* c */\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg /* c */\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg/* c1 */ /* c2 */\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg /* c1 */ /* c2 */\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg// c\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg // c\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg/* c1 */ // c2\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg /* c1 */ // c2\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg\n" - "/* c */);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg\n" - "/* c */);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg\n" - "/* c1 */ /* c2 */);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg\n" - "/* c1 */ /* c2 */);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg\n" - "/* c */\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg\n" - " /* c */\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg\n" - "/* c1 */ /* c2 */\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg\n" - " /* c1 */ /* c2 */\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg\n" - "// c\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg\n" - " // c\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg\n" - "/* c1 */ // c2\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg\n" - " /* c1 */ // c2\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg\n" - "/* c1 */\n" - "/* c2 */\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg\n" - " /* c1 */\n" - " /* c2 */\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg\n" - "// c1\n" - "// c2\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg\n" - " // c1\n" - " // c2\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg/* c1 */\n" - "/* c2 */);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg /* c1 */\n" - "/* c2 */);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg// c1\n" - "/* c2 */);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg // c1\n" - "/* c2 */);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg/* c1 */\n" - "/* c2 */\n" - "/* c3 */);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg /* c1 */\n" - " /* c2 */\n" - "/* c3 */);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg/* c1 */\n" - "/* c2 */\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg /* c1 */\n" - " /* c2 */\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg// c1\n" - "/* c2 */\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg // c1\n" - " /* c2 */\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg/* c1 */\n" - "// c2\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg /* c1 */\n" - " // c2\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg// c1\n" - "// c2\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg // c1\n" - " // c2\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg/* c1 */\n" - "/* c2 */\n" - "/* c3 */\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg /* c1 */\n" - " /* c2 */\n" - " /* c3 */\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg// c1\n" - "// c2\n" - "// c3\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg // c1\n" - " // c2\n" - " // c3\n" - ");\n"}, - - // before colon - - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1/* c */, arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1 /* c */, arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1/* c1 */ /* c2 */, arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1 /* c1 */ /* c2 */,\n" - " arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1/* c */\n" - ", arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1 /* c */\n" - " , arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1/* c1 */ /* c2 */\n" - ", arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1 /* c1 */ /* c2 */\n" - " , arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1// c\n" - ", arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1 // c\n" - " , arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1/* c1 */ // c2\n" - ", arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1 /* c1 */ // c2\n" - " , arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1\n" - "/* c */, arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1\n" - " /* c */, arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1\n" - "/* c1 */ /* c2 */, arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1\n" - " /* c1 */ /* c2 */, arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1\n" - "/* c */\n" - ", arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1\n" - " /* c */\n" - " , arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1\n" - "/* c1 */ /* c2 */\n" - ", arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1\n" - " /* c1 */ /* c2 */\n" - " , arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1\n" - "// c\n" - ", arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1\n" - " // c\n" - " , arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1\n" - "/* c1 */ // c2\n" - ", arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1\n" - " /* c1 */ // c2\n" - " , arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1\n" - "/* c1 */\n" - "/* c2 */\n" - ", arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1\n" - " /* c1 */\n" - " /* c2 */\n" - " , arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1\n" - "// c1\n" - "// c2\n" - ", arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1\n" - " // c1\n" - " // c2\n" - " , arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1/* c1 */\n" - "/* c2 */, arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1 /* c1 */\n" - " /* c2 */, arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1// c1\n" - "/* c2 */, arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1 // c1\n" - " /* c2 */, arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1/* c1 */\n" - "/* c2 */\n" - "/* c3 */, arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1 /* c1 */\n" - " /* c2 */\n" - " /* c3 */, arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1/* c1 */\n" - "/* c2 */\n" - ", arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1 /* c1 */\n" - " /* c2 */\n" - " , arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1// c1\n" - "/* c2 */\n" - ", arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1 // c1\n" - " /* c2 */\n" - " , arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1/* c1 */\n" - "// c2\n" - ", arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1 /* c1 */\n" - " // c2\n" - " , arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1// c1\n" - "// c2\n" - ", arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1 // c1\n" - " // c2\n" - " , arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1/* c1 */\n" - "/* c2 */\n" - "/* c3 */\n" - ", arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1 /* c1 */\n" - " /* c2 */\n" - " /* c3 */\n" - " , arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1// c1\n" - "// c2\n" - "// c3\n" - ", arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1 // c1\n" - " // c2\n" - " // c3\n" - " , arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1/* c */, arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1 /* c */, arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1/* c1 */ /* c2 */, arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1 /* c1 */ /* c2 */,\n" - " arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1/* c */\n" - ", arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1 /* c */\n" - " , arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1/* c1 */ /* c2 */\n" - ", arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1 /* c1 */ /* c2 */\n" - " , arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1// c\n" - ", arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1 // c\n" - " , arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1/* c1 */ // c2\n" - ", arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1 /* c1 */ // c2\n" - " , arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1\n" - "/* c */, arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1\n" - " /* c */, arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1\n" - "/* c1 */ /* c2 */, arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1\n" - " /* c1 */ /* c2 */, arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1\n" - "/* c */\n" - ", arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1\n" - " /* c */\n" - " , arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1\n" - "/* c1 */ /* c2 */\n" - ", arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1\n" - " /* c1 */ /* c2 */\n" - " , arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1\n" - "// c\n" - ", arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1\n" - " // c\n" - " , arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1\n" - "/* c1 */ // c2\n" - ", arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1\n" - " /* c1 */ // c2\n" - " , arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1\n" - "/* c1 */\n" - "/* c2 */\n" - ", arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1\n" - " /* c1 */\n" - " /* c2 */\n" - " , arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1\n" - "// c1\n" - "// c2\n" - ", arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1\n" - " // c1\n" - " // c2\n" - " , arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1/* c1 */\n" - "/* c2 */, arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1 /* c1 */\n" - " /* c2 */, arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1// c1\n" - "/* c2 */, arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1 // c1\n" - " /* c2 */, arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1/* c1 */\n" - "/* c2 */\n" - "/* c3 */, arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1 /* c1 */\n" - " /* c2 */\n" - " /* c3 */, arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1/* c1 */\n" - "/* c2 */\n" - ", arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1 /* c1 */\n" - " /* c2 */\n" - " , arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1// c1\n" - "/* c2 */\n" - ", arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1 // c1\n" - " /* c2 */\n" - " , arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1/* c1 */\n" - "// c2\n" - ", arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1 /* c1 */\n" - " // c2\n" - " , arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1// c1\n" - "// c2\n" - ", arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1 // c1\n" - " // c2\n" - " , arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1/* c1 */\n" - "/* c2 */\n" - "/* c3 */\n" - ", arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1 /* c1 */\n" - " /* c2 */\n" - " /* c3 */\n" - " , arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1// c1\n" - "// c2\n" - "// c3\n" - ", arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1 // c1\n" - " // c2\n" - " // c3\n" - " , arg2);\n"}, - - // after colon - - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1,/* c */arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1, /* c */ arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1,/* c1 */ /* c2 */arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1, /* c1 */ /* c2 */\n" - " arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1,/* c */\n" - "arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1, /* c */\n" - " arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1,/* c1 */ /* c2 */\n" - "arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1, /* c1 */ /* c2 */\n" - " arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1,// c\n" - "arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1, // c\n" - " arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1,/* c1 */ // c2\n" - "arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1, /* c1 */ // c2\n" - " arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1,\n" - "/* c */arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1,\n" - " /* c */ arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1,\n" - "/* c1 */ /* c2 */arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1,\n" - " /* c1 */ /* c2 */ arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1,\n" - "/* c */\n" - "arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1,\n" - " /* c */\n" - " arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1,\n" - "/* c1 */ /* c2 */\n" - "arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1,\n" - " /* c1 */ /* c2 */\n" - " arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1,\n" - "// c\n" - "arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1,\n" - " // c\n" - " arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1,\n" - "/* c1 */ // c2\n" - "arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1,\n" - " /* c1 */ // c2\n" - " arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1,\n" - "/* c1 */\n" - "/* c2 */\n" - "arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1,\n" - " /* c1 */\n" - " /* c2 */\n" - " arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1,\n" - "// c1\n" - "// c2\n" - "arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1,\n" - " // c1\n" - " // c2\n" - " arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1,/* c1 */\n" - "/* c2 */arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1, /* c1 */\n" - " /* c2 */ arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1,// c1\n" - "/* c2 */arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1, // c1\n" - " /* c2 */ arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1,/* c1 */\n" - "/* c2 */\n" - "/* c3 */arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1, /* c1 */\n" - " /* c2 */\n" - " /* c3 */ arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1,/* c1 */\n" - "/* c2 */\n" - "arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1, /* c1 */\n" - " /* c2 */\n" - " arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1,// c1\n" - "/* c2 */\n" - "arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1, // c1\n" - " /* c2 */\n" - " arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1,/* c1 */\n" - "// c2\n" - "arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1, /* c1 */\n" - " // c2\n" - " arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1,// c1\n" - "// c2\n" - "arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1, // c1\n" - " // c2\n" - " arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1,/* c1 */\n" - "/* c2 */\n" - "/* c3 */\n" - "arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1, /* c1 */\n" - " /* c2 */\n" - " /* c3 */\n" - " arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1,// c1\n" - "// c2\n" - "// c3\n" - "arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1, // c1\n" - " // c2\n" - " // c3\n" - " arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1,/* c */arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1, /* c */ arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1,/* c1 */ /* c2 */arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1, /* c1 */ /* c2 */\n" - " arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1,/* c */\n" - "arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1, /* c */\n" - " arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1,/* c1 */ /* c2 */\n" - "arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1, /* c1 */ /* c2 */\n" - " arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1,// c\n" - "arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1, // c\n" - " arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1,/* c1 */ // c2\n" - "arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1, /* c1 */ // c2\n" - " arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1,\n" - "/* c */arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1,\n" - " /* c */ arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1,\n" - "/* c1 */ /* c2 */arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1,\n" - " /* c1 */ /* c2 */ arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1,\n" - "/* c */\n" - "arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1,\n" - " /* c */\n" - " arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1,\n" - "/* c1 */ /* c2 */\n" - "arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1,\n" - " /* c1 */ /* c2 */\n" - " arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1,\n" - "// c\n" - "arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1,\n" - " // c\n" - " arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1,\n" - "/* c1 */ // c2\n" - "arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1,\n" - " /* c1 */ // c2\n" - " arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1,\n" - "/* c1 */\n" - "/* c2 */\n" - "arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1,\n" - " /* c1 */\n" - " /* c2 */\n" - " arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1,\n" - "// c1\n" - "// c2\n" - "arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1,\n" - " // c1\n" - " // c2\n" - " arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1,/* c1 */\n" - "/* c2 */arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1, /* c1 */\n" - " /* c2 */ arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1,// c1\n" - "/* c2 */arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1, // c1\n" - " /* c2 */ arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1,/* c1 */\n" - "/* c2 */\n" - "/* c3 */arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1, /* c1 */\n" - " /* c2 */\n" - " /* c3 */ arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1,/* c1 */\n" - "/* c2 */\n" - "arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1, /* c1 */\n" - " /* c2 */\n" - " arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1,// c1\n" - "/* c2 */\n" - "arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1, // c1\n" - " /* c2 */\n" - " arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1,/* c1 */\n" - "// c2\n" - "arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1, /* c1 */\n" - " // c2\n" - " arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1,// c1\n" - "// c2\n" - "arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1, // c1\n" - " // c2\n" - " arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1,/* c1 */\n" - "/* c2 */\n" - "/* c3 */\n" - "arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1, /* c1 */\n" - " /* c2 */\n" - " /* c3 */\n" - " arg2);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1,// c1\n" - "// c2\n" - "// c3\n" - "arg2);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1, // c1\n" - " // c2\n" - " // c3\n" - " arg2);\n"}, - - // after last arg - - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1, arg2,/* c */);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1, arg2, /* c */);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1, arg2,/* c1 */ /* c2 */);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1,\n" - " arg2, /* c1 */ /* c2 */);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1, arg2,/* c */\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1, arg2, /* c */\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1, arg2,/* c1 */ /* c2 */\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1,\n" - " arg2, /* c1 */ /* c2 */\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1, arg2,// c\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1, arg2, // c\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1, arg2,/* c1 */ // c2\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1, arg2, /* c1 */ // c2\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1, arg2,\n" - "/* c */);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1, arg2,\n" - "/* c */);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1, arg2,\n" - "/* c1 */ /* c2 */);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1, arg2,\n" - "/* c1 */ /* c2 */);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1, arg2,\n" - "/* c */\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1, arg2,\n" - " /* c */\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1, arg2,\n" - "/* c1 */ /* c2 */\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1, arg2,\n" - " /* c1 */ /* c2 */\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1, arg2,\n" - "// c\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1, arg2,\n" - " // c\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1, arg2,\n" - "/* c1 */ // c2\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1, arg2,\n" - " /* c1 */ // c2\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1, arg2,\n" - "/* c1 */\n" - "/* c2 */\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1, arg2,\n" - " /* c1 */\n" - " /* c2 */\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1, arg2,\n" - "// c1\n" - "// c2\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1, arg2,\n" - " // c1\n" - " // c2\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1, arg2,/* c1 */\n" - "/* c2 */);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1, arg2, /* c1 */\n" - "/* c2 */);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1, arg2,// c1\n" - "/* c2 */);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1, arg2, // c1\n" - "/* c2 */);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1, arg2,/* c1 */\n" - "/* c2 */\n" - "/* c3 */);\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1, arg2, /* c1 */\n" - " /* c2 */\n" - "/* c3 */);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1, arg2,/* c1 */\n" - "/* c2 */\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1, arg2, /* c1 */\n" - " /* c2 */\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1, arg2,// c1\n" - "/* c2 */\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1, arg2, // c1\n" - " /* c2 */\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1, arg2,/* c1 */\n" - "// c2\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1, arg2, /* c1 */\n" - " // c2\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1, arg2,// c1\n" - "// c2\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1, arg2, // c1\n" - " // c2\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1, arg2,/* c1 */\n" - "/* c2 */\n" - "/* c3 */\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1, arg2, /* c1 */\n" - " /* c2 */\n" - " /* c3 */\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1, arg2,// c1\n" - "// c2\n" - "// c3\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg1, arg2, // c1\n" - " // c2\n" - " // c3\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1, arg2,/* c */);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1, arg2, /* c */);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1, arg2,/* c1 */ /* c2 */);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1,\n" - " arg2, /* c1 */ /* c2 */);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1, arg2,/* c */\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1, arg2, /* c */\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1, arg2,/* c1 */ /* c2 */\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1,\n" - " arg2, /* c1 */ /* c2 */\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1, arg2,// c\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1, arg2, // c\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1, arg2,/* c1 */ // c2\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1, arg2, /* c1 */ // c2\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1, arg2,\n" - "/* c */);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1, arg2,\n" - "/* c */);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1, arg2,\n" - "/* c1 */ /* c2 */);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1, arg2,\n" - "/* c1 */ /* c2 */);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1, arg2,\n" - "/* c */\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1, arg2,\n" - " /* c */\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1, arg2,\n" - "/* c1 */ /* c2 */\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1, arg2,\n" - " /* c1 */ /* c2 */\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1, arg2,\n" - "// c\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1, arg2,\n" - " // c\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1, arg2,\n" - "/* c1 */ // c2\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1, arg2,\n" - " /* c1 */ // c2\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1, arg2,\n" - "/* c1 */\n" - "/* c2 */\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1, arg2,\n" - " /* c1 */\n" - " /* c2 */\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1, arg2,\n" - "// c1\n" - "// c2\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1, arg2,\n" - " // c1\n" - " // c2\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1, arg2,/* c1 */\n" - "/* c2 */);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1, arg2, /* c1 */\n" - "/* c2 */);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1, arg2,// c1\n" - "/* c2 */);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1, arg2, // c1\n" - "/* c2 */);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1, arg2,/* c1 */\n" - "/* c2 */\n" - "/* c3 */);\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1, arg2, /* c1 */\n" - " /* c2 */\n" - "/* c3 */);\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1, arg2,/* c1 */\n" - "/* c2 */\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1, arg2, /* c1 */\n" - " /* c2 */\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1, arg2,// c1\n" - "/* c2 */\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1, arg2, // c1\n" - " /* c2 */\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1, arg2,/* c1 */\n" - "// c2\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1, arg2, /* c1 */\n" - " // c2\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1, arg2,// c1\n" - "// c2\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1, arg2, // c1\n" - " // c2\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1, arg2,/* c1 */\n" - "/* c2 */\n" - "/* c3 */\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1, arg2, /* c1 */\n" - " /* c2 */\n" - " /* c3 */\n" - ");\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1, arg2,// c1\n" - "// c2\n" - "// c3\n" - ");\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg1, arg2, // c1\n" - " // c2\n" - " // c3\n" - ");\n"}, - - // after ')', no args - - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz()/* c */;\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz() /* c */;\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz()/* c1 */ /* c2 */;\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz() /* c1 */ /* c2 */;\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz()/* c */\n" - ";\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz() /* c */\n" - ";\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz()/* c1 */ /* c2 */\n" - ";\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz() /* c1 */ /* c2 */\n" - ";\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz()// c\n" - ";\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz() // c\n" - ";\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz()/* c1 */ // c2\n" - ";\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz() /* c1 */ // c2\n" - ";\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz()\n" - "/* c */;\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz()\n" - "/* c */;\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz()\n" - "/* c1 */ /* c2 */;\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz()\n" - "/* c1 */ /* c2 */;\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz()\n" - "/* c */\n" - ";\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz()\n" - "/* c */\n" - ";\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz()\n" - "/* c1 */ /* c2 */\n" - ";\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz()\n" - "/* c1 */ /* c2 */\n" - ";\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz()\n" - "// c\n" - ";\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz()\n" - "// c\n" - ";\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz()\n" - "/* c1 */ // c2\n" - ";\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz()\n" - "/* c1 */ // c2\n" - ";\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz()\n" - "/* c1 */\n" - "/* c2 */\n" - ";\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz()\n" - "/* c1 */\n" - "/* c2 */\n" - ";\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz()\n" - "// c1\n" - "// c2\n" - ";\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz()\n" - "// c1\n" - "// c2\n" - ";\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz()/* c1 */\n" - "/* c2 */;\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz() /* c1 */\n" - "/* c2 */;\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz()// c1\n" - "/* c2 */;\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz() // c1\n" - "/* c2 */;\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz()/* c1 */\n" - "/* c2 */\n" - "/* c3 */;\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz() /* c1 */\n" - "/* c2 */\n" - "/* c3 */;\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz()/* c1 */\n" - "/* c2 */\n" - ";\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz() /* c1 */\n" - "/* c2 */\n" - ";\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz()// c1\n" - "/* c2 */\n" - ";\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz() // c1\n" - "/* c2 */\n" - ";\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz()/* c1 */\n" - "// c2\n" - ";\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz() /* c1 */\n" - "// c2\n" - ";\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz()// c1\n" - "// c2\n" - ";\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz() // c1\n" - "// c2\n" - ";\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz()/* c1 */\n" - "/* c2 */\n" - "/* c3 */\n" - ";\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz() /* c1 */\n" - "/* c2 */\n" - "/* c3 */\n" - ";\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz()// c1\n" - "// c2\n" - "// c3\n" - ";\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz() // c1\n" - "// c2\n" - "// c3\n" - ";\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ()/* c */;\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ() /* c */;\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ()/* c1 */ /* c2 */;\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ() /* c1 */ /* c2 */;\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ()/* c */\n" - ";\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ() /* c */\n" - ";\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ()/* c1 */ /* c2 */\n" - ";\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ() /* c1 */ /* c2 */\n" - ";\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ()// c\n" - ";\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ() // c\n" - ";\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ()/* c1 */ // c2\n" - ";\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ() /* c1 */ // c2\n" - ";\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ()\n" - "/* c */;\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ()\n" - "/* c */;\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ()\n" - "/* c1 */ /* c2 */;\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ()\n" - "/* c1 */ /* c2 */;\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ()\n" - "/* c */\n" - ";\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ()\n" - "/* c */\n" - ";\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ()\n" - "/* c1 */ /* c2 */\n" - ";\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ()\n" - "/* c1 */ /* c2 */\n" - ";\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ()\n" - "// c\n" - ";\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ()\n" - "// c\n" - ";\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ()\n" - "/* c1 */ // c2\n" - ";\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ()\n" - "/* c1 */ // c2\n" - ";\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ()\n" - "/* c1 */\n" - "/* c2 */\n" - ";\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ()\n" - "/* c1 */\n" - "/* c2 */\n" - ";\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ()\n" - "// c1\n" - "// c2\n" - ";\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ()\n" - "// c1\n" - "// c2\n" - ";\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ()/* c1 */\n" - "/* c2 */;\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ() /* c1 */\n" - "/* c2 */;\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ()// c1\n" - "/* c2 */;\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ() // c1\n" - "/* c2 */;\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ()/* c1 */\n" - "/* c2 */\n" - "/* c3 */;\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ() /* c1 */\n" - "/* c2 */\n" - "/* c3 */;\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ()/* c1 */\n" - "/* c2 */\n" - ";\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ() /* c1 */\n" - "/* c2 */\n" - ";\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ()// c1\n" - "/* c2 */\n" - ";\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ() // c1\n" - "/* c2 */\n" - ";\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ()/* c1 */\n" - "// c2\n" - ";\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ() /* c1 */\n" - "// c2\n" - ";\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ()// c1\n" - "// c2\n" - ";\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ() // c1\n" - "// c2\n" - ";\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ()/* c1 */\n" - "/* c2 */\n" - "/* c3 */\n" - ";\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ() /* c1 */\n" - "/* c2 */\n" - "/* c3 */\n" - ";\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ()// c1\n" - "// c2\n" - "// c3\n" - ";\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ() // c1\n" - "// c2\n" - "// c3\n" - ";\n"}, - - // after ')', with arg - - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg)/* c */;\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg) /* c */;\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg)/* c1 */ /* c2 */;\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg) /* c1 */ /* c2 */;\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg)/* c */\n" - ";\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg) /* c */\n" - ";\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg)/* c1 */ /* c2 */\n" - ";\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg) /* c1 */ /* c2 */\n" - ";\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg)// c\n" - ";\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg) // c\n" - ";\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg)/* c1 */ // c2\n" - ";\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg) /* c1 */ // c2\n" - ";\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg)\n" - "/* c */;\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg)\n" - "/* c */;\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg)\n" - "/* c1 */ /* c2 */;\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg)\n" - "/* c1 */ /* c2 */;\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg)\n" - "/* c */\n" - ";\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg)\n" - "/* c */\n" - ";\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg)\n" - "/* c1 */ /* c2 */\n" - ";\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg)\n" - "/* c1 */ /* c2 */\n" - ";\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg)\n" - "// c\n" - ";\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg) // c\n" - ";\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg)\n" - "/* c1 */ // c2\n" - ";\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg)\n" - "/* c1 */ // c2\n" - ";\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg)\n" - "/* c1 */\n" - "/* c2 */\n" - ";\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg)\n" - "/* c1 */\n" - "/* c2 */\n" - ";\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg)\n" - "// c1\n" - "// c2\n" - ";\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg)\n" - "// c1\n" - "// c2\n" - ";\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg)/* c1 */\n" - "/* c2 */;\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg) /* c1 */\n" - "/* c2 */;\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg)// c1\n" - "/* c2 */;\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg) // c1\n" - "/* c2 */;\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg)/* c1 */\n" - "/* c2 */\n" - "/* c3 */;\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg) /* c1 */\n" - "/* c2 */\n" - "/* c3 */;\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg)/* c1 */\n" - "/* c2 */\n" - ";\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg) /* c1 */\n" - "/* c2 */\n" - ";\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg)// c1\n" - "/* c2 */\n" - ";\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg) // c1\n" - "/* c2 */\n" - ";\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg)/* c1 */\n" - "// c2\n" - ";\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg) /* c1 */\n" - "// c2\n" - ";\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg)// c1\n" - "// c2\n" - ";\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg) // c1\n" - "// c2\n" - ";\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg)/* c1 */\n" - "/* c2 */\n" - "/* c3 */\n" - ";\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg) /* c1 */\n" - "/* c2 */\n" - "/* c3 */\n" - ";\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg)// c1\n" - "// c2\n" - "// c3\n" - ";\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg) // c1\n" - "// c2\n" - "// c3\n" - ";\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg)/* c */;\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg) /* c */;\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg)/* c1 */ /* c2 */;\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg) /* c1 */ /* c2 */;\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg)/* c */\n" - ";\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg) /* c */\n" - ";\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg)/* c1 */ /* c2 */\n" - ";\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg) /* c1 */ /* c2 */\n" - ";\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg)// c\n" - ";\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg) // c\n" - ";\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg)/* c1 */ // c2\n" - ";\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg) /* c1 */ // c2\n" - ";\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg)\n" - "/* c */;\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg)\n" - "/* c */;\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg)\n" - "/* c1 */ /* c2 */;\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg)\n" - "/* c1 */ /* c2 */;\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg)\n" - "/* c */\n" - ";\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg)\n" - "/* c */\n" - ";\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg)\n" - "/* c1 */ /* c2 */\n" - ";\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg)\n" - "/* c1 */ /* c2 */\n" - ";\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg)\n" - "// c\n" - ";\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg)\n" - "// c\n" - ";\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg)\n" - "/* c1 */ // c2\n" - ";\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg)\n" - "/* c1 */ // c2\n" - ";\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg)\n" - "/* c1 */\n" - "/* c2 */\n" - ";\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg)\n" - "/* c1 */\n" - "/* c2 */\n" - ";\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg)\n" - "// c1\n" - "// c2\n" - ";\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg)\n" - "// c1\n" - "// c2\n" - ";\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg)/* c1 */\n" - "/* c2 */;\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg) /* c1 */\n" - "/* c2 */;\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg)// c1\n" - "/* c2 */;\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg) // c1\n" - "/* c2 */;\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg)/* c1 */\n" - "/* c2 */\n" - "/* c3 */;\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg) /* c1 */\n" - "/* c2 */\n" - "/* c3 */;\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg)/* c1 */\n" - "/* c2 */\n" - ";\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg) /* c1 */\n" - "/* c2 */\n" - ";\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg)// c1\n" - "/* c2 */\n" - ";\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg) // c1\n" - "/* c2 */\n" - ";\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg)/* c1 */\n" - "// c2\n" - ";\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg) /* c1 */\n" - "// c2\n" - ";\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg)// c1\n" - "// c2\n" - ";\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg) // c1\n" - "// c2\n" - ";\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg)/* c1 */\n" - "/* c2 */\n" - "/* c3 */\n" - ";\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg) /* c1 */\n" - "/* c2 */\n" - "/* c3 */\n" - ";\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg)// c1\n" - "// c2\n" - "// c3\n" - ";\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg) // c1\n" - "// c2\n" - "// c3\n" - ";\n"}, - - // after ';', no args - - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz();/* c */\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(); /* c */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz();/* c1 */ /* c2 */\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(); /* c1 */ /* c2 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz();/* c */\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(); /* c */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz();/* c1 */ /* c2 */\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(); /* c1 */ /* c2 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz();// c\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(); // c\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz();/* c1 */ // c2\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(); /* c1 */ // c2\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz();\n" - "/* c */\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz();\n" - "/* c */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz();\n" - "/* c1 */ /* c2 */\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz();\n" - "/* c1 */ /* c2 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz();\n" - "/* c */\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz();\n" - "/* c */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz();\n" - "/* c1 */ /* c2 */\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz();\n" - "/* c1 */ /* c2 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz();\n" - "// c\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz();\n" - "// c\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz();\n" - "/* c1 */ // c2\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz();\n" - "/* c1 */ // c2\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz();\n" - "/* c1 */\n" - "/* c2 */\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz();\n" - "/* c1 */\n" - "/* c2 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz();\n" - "// c1\n" - "// c2\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz();\n" - "// c1\n" - "// c2\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz();/* c1 */\n" - "/* c2 */\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(); /* c1 */\n" - "/* c2 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz();// c1\n" - "/* c2 */\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(); // c1\n" - "/* c2 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz();/* c1 */\n" - "/* c2 */\n" - "/* c3 */\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(); /* c1 */\n" - "/* c2 */\n" - "/* c3 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz();/* c1 */\n" - "/* c2 */\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(); /* c1 */\n" - "/* c2 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz();// c1 c2 */\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(); // c1 c2 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz();/* c1 */\n" - "// c2\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(); /* c1 */\n" - "// c2\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz();// c1\n" - "// c2\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(); // c1\n" - "// c2\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz();/* c1 */\n" - "/* c2 */\n" - "/* c3 */\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(); /* c1 */\n" - "/* c2 */\n" - "/* c3 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz();// c1\n" - "// c2\n" - "// c3\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(); // c1\n" - "// c2\n" - "// c3\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ();/* c */\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(); /* c */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ();/* c1 */ /* c2 */\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(); /* c1 */ /* c2 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ();/* c */\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(); /* c */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ();/* c1 */ /* c2 */\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(); /* c1 */ /* c2 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ();// c\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(); // c\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ();/* c1 */ // c2\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(); /* c1 */ // c2\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ();\n" - "/* c */\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ();\n" - "/* c */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ();\n" - "/* c1 */ /* c2 */\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ();\n" - "/* c1 */ /* c2 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ();\n" - "/* c */\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ();\n" - "/* c */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ();\n" - "/* c1 */ /* c2 */\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ();\n" - "/* c1 */ /* c2 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ();\n" - "// c\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ();\n" - "// c\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ();\n" - "/* c1 */ // c2\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ();\n" - "/* c1 */ // c2\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ();\n" - "/* c1 */\n" - "/* c2 */\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ();\n" - "/* c1 */\n" - "/* c2 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ();\n" - "// c1\n" - "// c2\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ();\n" - "// c1\n" - "// c2\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ();/* c1 */\n" - "/* c2 */\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(); /* c1 */\n" - "/* c2 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ();// c1\n" - "/* c2 */\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(); // c1\n" - "/* c2 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ();/* c1 */\n" - "/* c2 */\n" - "/* c3 */\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(); /* c1 */\n" - "/* c2 */\n" - "/* c3 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ();/* c1 */\n" - "/* c2 */\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(); /* c1 */\n" - "/* c2 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ();// c1\n" - "/* c2 */\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(); // c1\n" - "/* c2 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ();/* c1 */\n" - "// c2\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(); /* c1 */\n" - "// c2\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ();// c1\n" - "// c2\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(); // c1\n" - "// c2\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ();/* c1 */\n" - "/* c2 */\n" - "/* c3 */\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(); /* c1 */\n" - "/* c2 */\n" - "/* c3 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ();// c1\n" - "// c2\n" - "// c3\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(); // c1\n" - "// c2\n" - "// c3\n"}, - - // after ';', with arg - - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg);/* c */\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg); /* c */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg);/* c1 */ /* c2 */\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg); /* c1 */ /* c2 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg);/* c */\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg); /* c */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg);/* c1 */ /* c2 */\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg); /* c1 */ /* c2 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg);// c\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg); // c\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg);/* c1 */ // c2\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg); /* c1 */ // c2\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg);\n" - "/* c */\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg);\n" - "/* c */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg);\n" - "/* c1 */ /* c2 */\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg);\n" - "/* c1 */ /* c2 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg);\n" - "/* c */\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg);\n" - "/* c */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg);\n" - "/* c1 */ /* c2 */\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg);\n" - "/* c1 */ /* c2 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg);\n" - "// c\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg);\n" - "// c\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg);\n" - "/* c1 */ // c2\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg);\n" - "/* c1 */ // c2\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg);\n" - "/* c1 */\n" - "/* c2 */\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg);\n" - "/* c1 */\n" - "/* c2 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg);\n" - "// c1\n" - "// c2\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg);\n" - "// c1\n" - "// c2\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg);/* c1 */\n" - "/* c2 */\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg); /* c1 */\n" - "/* c2 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg);// c1\n" - "/* c2 */\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg); // c1\n" - "/* c2 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg);/* c1 */\n" - "/* c2 */\n" - "/* c3 */\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg); /* c1 */\n" - "/* c2 */\n" - "/* c3 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg);/* c1 */\n" - "/* c2 */\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg); /* c1 */\n" - "/* c2 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg);// c1 c2 */\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg); // c1 c2 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg);/* c1 */\n" - "// c2\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg); /* c1 */\n" - "// c2\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg);// c1\n" - "// c2\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg); // c1\n" - "// c2\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg);/* c1 */\n" - "/* c2 */\n" - "/* c3 */\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg); /* c1 */\n" - "/* c2 */\n" - "/* c3 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg);// c1\n" - "// c2\n" - "// c3\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz(arg); // c1\n" - "// c2\n" - "// c3\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg);/* c */\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg); /* c */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg);/* c1 */ /* c2 */\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg); /* c1 */ /* c2 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg);/* c */\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg); /* c */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg);/* c1 */ /* c2 */\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg); /* c1 */ /* c2 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg);// c\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg); // c\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg);/* c1 */ // c2\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg); /* c1 */ // c2\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg);\n" - "/* c */\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg);\n" - "/* c */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg);\n" - "/* c1 */ /* c2 */\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg);\n" - "/* c1 */ /* c2 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg);\n" - "/* c */\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg);\n" - "/* c */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg);\n" - "/* c1 */ /* c2 */\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg);\n" - "/* c1 */ /* c2 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg);\n" - "// c\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg);\n" - "// c\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg);\n" - "/* c1 */ // c2\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg);\n" - "/* c1 */ // c2\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg);\n" - "/* c1 */\n" - "/* c2 */\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg);\n" - "/* c1 */\n" - "/* c2 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg);\n" - "// c1\n" - "// c2\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg);\n" - "// c1\n" - "// c2\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg);/* c1 */\n" - "/* c2 */\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg); /* c1 */\n" - "/* c2 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg);// c1\n" - "/* c2 */\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg); // c1\n" - "/* c2 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg);/* c1 */\n" - "/* c2 */\n" - "/* c3 */\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg); /* c1 */\n" - "/* c2 */\n" - "/* c3 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg);/* c1 */\n" - "/* c2 */\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg); /* c1 */\n" - "/* c2 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg);// c1\n" - "/* c2 */\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg); // c1\n" - "/* c2 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg);/* c1 */\n" - "// c2\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg); /* c1 */\n" - "// c2\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg);// c1\n" - "// c2\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg); // c1\n" - "// c2\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg);/* c1 */\n" - "/* c2 */\n" - "/* c3 */\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg); /* c1 */\n" - "/* c2 */\n" - "/* c3 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg);// c1\n" - "// c2\n" - "// c3\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(arg); // c1\n" - "// c2\n" - "// c3\n"}, - - // everywhere, no args - - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz/* c */(/* c */)/* c */;/* c */\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz /* c */\n" - " ( /* c */) /* c */; /* c */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz/* c1 */ /* c2 */(/* c1 */ /* c2 */)/* c1 */ /* c2 */;/* c1 */ " - "/* c2 */\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz /* c1 */ /* c2 */\n" - " ( /* c1 */ /* c2 */) /* c1 */ /* c2 */; /* c1 */ /* c2 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz/* c */\n" - "(/* c */\n" - ")/* c */\n" - ";/* c */\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz /* c */\n" - " ( /* c */\n" - " ) /* c */\n" - "; /* c */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz/* c1 */ /* c2 */\n" - "(/* c1 */ /* c2 */\n" - ")/* c1 */ /* c2 */\n" - ";/* c1 */ /* c2 */\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz /* c1 */ /* c2 */\n" - " ( /* c1 */ /* c2 */\n" - " ) /* c1 */ /* c2 */\n" - "; /* c1 */ /* c2 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz// c\n" - "(// c\n" - ")// c\n" - ";// c\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz // c\n" - " ( // c\n" - " ) // c\n" - "; // c\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz/* c1 */ // c2\n" - "(/* c1 */ // c2\n" - ")/* c1 */ // c2\n" - ";/* c1 */ // c2\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz /* c1 */ // c2\n" - " ( /* c1 */ // c2\n" - " ) /* c1 */ // c2\n" - "; /* c1 */ // c2\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz\n" - "/* c */(\n" - "/* c */)\n" - "/* c */;\n" - "/* c */\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz\n" - " /* c */ (\n" - " /* c */)\n" - "/* c */;\n" - "/* c */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz\n" - "/* c1 */ /* c2 */(\n" - "/* c1 */ /* c2 */)\n" - "/* c1 */ /* c2 */;\n" - "/* c1 */ /* c2 */\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz\n" - " /* c1 */ /* c2 */ (\n" - " /* c1 */ /* c2 */)\n" - "/* c1 */ /* c2 */;\n" - "/* c1 */ /* c2 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz\n" - "/* c */\n" - "(\n" - "/* c */\n" - ")\n" - "/* c */\n" - ";\n" - "/* c */\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz\n" - " /* c */\n" - " (\n" - " /* c */\n" - " )\n" - "/* c */\n" - ";\n" - "/* c */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz\n" - "/* c1 */ /* c2 */\n" - "(\n" - "/* c1 */ /* c2 */\n" - ")\n" - "/* c1 */ /* c2 */\n" - ";\n" - "/* c1 */ /* c2 */\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz\n" - " /* c1 */ /* c2 */\n" - " (\n" - " /* c1 */ /* c2 */\n" - " )\n" - "/* c1 */ /* c2 */\n" - ";\n" - "/* c1 */ /* c2 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz\n" - "// c\n" - "(\n" - "// c\n" - ")\n" - "// c\n" - ";\n" - "// c\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz\n" - " // c\n" - " (\n" - " // c\n" - " )\n" - "// c\n" - ";\n" - "// c\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz\n" - "/* c1 */ // c2\n" - "(\n" - "/* c1 */ // c2\n" - ")\n" - "/* c1 */ // c2\n" - ";\n" - "/* c1 */ // c2\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz\n" - " /* c1 */ // c2\n" - " (\n" - " /* c1 */ // c2\n" - " )\n" - "/* c1 */ // c2\n" - ";\n" - "/* c1 */ // c2\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz\n" - "/* c1 */\n" - "/* c2 */\n" - "(\n" - "/* c1 */\n" - "/* c2 */\n" - ")\n" - "/* c1 */\n" - "/* c2 */\n" - ";\n" - "/* c1 */\n" - "/* c2 */\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz\n" - " /* c1 */\n" - " /* c2 */\n" - " (\n" - " /* c1 */\n" - " /* c2 */\n" - " )\n" - "/* c1 */\n" - "/* c2 */\n" - ";\n" - "/* c1 */\n" - "/* c2 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz\n" - "// c1\n" - "// c2\n" - "(\n" - "// c1\n" - "// c2\n" - ")\n" - "// c1\n" - "// c2\n" - ";\n" - "// c1\n" - "// c2\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz\n" - " // c1\n" - " // c2\n" - " (\n" - " // c1\n" - " // c2\n" - " )\n" - "// c1\n" - "// c2\n" - ";\n" - "// c1\n" - "// c2\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz/* c1 */\n" - "/* c2 */(/* c1 */\n" - "/* c2 */)/* c1 */\n" - "/* c2 */;/* c1 */\n" - "/* c2 */\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz /* c1 */\n" - " /* c2 */ ( /* c1 */\n" - " /* c2 */) /* c1 */\n" - "/* c2 */; /* c1 */\n" - "/* c2 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz// c1\n" - "/* c2 */(// c1\n" - "/* c2 */)// c1\n" - "/* c2 */;// c1\n" - "/* c2 */\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz // c1\n" - " /* c2 */ ( // c1\n" - " /* c2 */) // c1\n" - "/* c2 */; // c1\n" - "/* c2 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz/* c1 */\n" - "/* c2 */\n" - "/* c3 */(/* c1 */\n" - "/* c2 */\n" - "/* c3 */)/* c1 */\n" - "/* c2 */\n" - "/* c3 */;/* c1 */\n" - "/* c2 */\n" - "/* c3 */\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz /* c1 */\n" - " /* c2 */\n" - " /* c3 */ ( /* c1 */\n" - " /* c2 */\n" - " /* c3 */) /* c1 */\n" - "/* c2 */\n" - "/* c3 */; /* c1 */\n" - "/* c2 */\n" - "/* c3 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz/* c1 */\n" - "/* c2 */\n" - "(/* c1 */\n" - "/* c2 */\n" - ")/* c1 */\n" - "/* c2 */\n" - ";/* c1 */\n" - "/* c2 */\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz /* c1 */\n" - " /* c2 */\n" - " ( /* c1 */\n" - " /* c2 */\n" - " ) /* c1 */\n" - "/* c2 */\n" - "; /* c1 */\n" - "/* c2 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz// c1\n" - "/* c2 */\n" - "(// c1\n" - "/* c2 */\n" - ")// c1\n" - "/* c2 */\n" - ";// c1\n" - "/* c2 */\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz // c1\n" - " /* c2 */\n" - " ( // c1\n" - " /* c2 */\n" - " ) // c1\n" - "/* c2 */\n" - "; // c1\n" - "/* c2 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz/* c1 */\n" - "// c2\n" - "(/* c1 */\n" - "// c2\n" - ")/* c1 */\n" - "// c2\n" - ";/* c1 */\n" - "// c2\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz /* c1 */\n" - " // c2\n" - " ( /* c1 */\n" - " // c2\n" - " ) /* c1 */\n" - "// c2\n" - "; /* c1 */\n" - "// c2\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz// c1\n" - "// c2\n" - "(// c1\n" - "// c2\n" - ")// c1\n" - "// c2\n" - ";// c1\n" - "// c2\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz // c1\n" - " // c2\n" - " ( // c1\n" - " // c2\n" - " ) // c1\n" - " // c2\n" - "; // c1\n" - " // c2\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz/* c1 */\n" - "/* c2 */\n" - "/* c3 */\n" - "(/* c1 */\n" - "/* c2 */\n" - "/* c3 */\n" - ")/* c1 */\n" - "/* c2 */\n" - "/* c3 */\n" - ";/* c1 */\n" - "/* c2 */\n" - "/* c3 */\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz /* c1 */\n" - " /* c2 */\n" - " /* c3 */\n" - " ( /* c1 */\n" - " /* c2 */\n" - " /* c3 */\n" - " ) /* c1 */\n" - "/* c2 */\n" - "/* c3 */\n" - "; /* c1 */\n" - "/* c2 */\n" - "/* c3 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz// c1\n" - "// c2\n" - "// c3\n" - "(// c1\n" - "// c2\n" - "// c3\n" - ")// c1\n" - "// c2\n" - "// c3\n" - ";// c1\n" - "// c2\n" - "// c3\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz // c1\n" - " // c2\n" - " // c3\n" - " ( // c1\n" - " // c2\n" - " // c3\n" - " ) // c1\n" - " // c2\n" - " // c3\n" - "; // c1\n" - " // c2\n" - " // c3\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(/* c */)/* c */;/* c */\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ( /* c */) /* c */; /* c */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(/* c1 */ /* c2 */)/* c1 */ /* c2 */;/* c1 */ /* c2 */\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ( /* c1 */ /* c2 */) /* c1 */ /* c2 */; /* c1 */ /* c2 " - "*/\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(/* c */\n" - ")/* c */\n" - ";/* c */\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ( /* c */\n" - ") /* c */\n" - "; /* c */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(/* c1 */ /* c2 */\n" - ")/* c1 */ /* c2 */\n" - ";/* c1 */ /* c2 */\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ( /* c1 */ /* c2 */\n" - ") /* c1 */ /* c2 */\n" - "; /* c1 */ /* c2 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(// c\n" - ")// c\n" - ";// c\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ( // c\n" - ") // c\n" - "; // c\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(/* c1 */ // c2\n" - ")/* c1 */ // c2\n" - ";/* c1 */ // c2\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ( /* c1 */ // c2\n" - ") /* c1 */ // c2\n" - "; /* c1 */ // c2\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(\n" - "/* c */)\n" - "/* c */;\n" - "/* c */\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(\n" - "/* c */)\n" - "/* c */;\n" - "/* c */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(\n" - "/* c1 */ /* c2 */)\n" - "/* c1 */ /* c2 */;\n" - "/* c1 */ /* c2 */\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(\n" - "/* c1 */ /* c2 */)\n" - "/* c1 */ /* c2 */;\n" - "/* c1 */ /* c2 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(\n" - "/* c */\n" - ")\n" - "/* c */\n" - ";\n" - "/* c */\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(\n" - " /* c */\n" - ")\n" - "/* c */\n" - ";\n" - "/* c */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(\n" - "/* c1 */ /* c2 */\n" - ")\n" - "/* c1 */ /* c2 */\n" - ";\n" - "/* c1 */ /* c2 */\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(\n" - " /* c1 */ /* c2 */\n" - ")\n" - "/* c1 */ /* c2 */\n" - ";\n" - "/* c1 */ /* c2 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(\n" - "// c\n" - ")\n" - "// c\n" - ";\n" - "// c\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(\n" - " // c\n" - ")\n" - "// c\n" - ";\n" - "// c\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(\n" - "/* c1 */ // c2\n" - ")\n" - "/* c1 */ // c2\n" - ";\n" - "/* c1 */ // c2\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(\n" - " /* c1 */ // c2\n" - ")\n" - "/* c1 */ // c2\n" - ";\n" - "/* c1 */ // c2\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(\n" - "/* c1 */\n" - "/* c2 */\n" - ")\n" - "/* c1 */\n" - "/* c2 */\n" - ";\n" - "/* c1 */\n" - "/* c2 */\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(\n" - " /* c1 */\n" - " /* c2 */\n" - ")\n" - "/* c1 */\n" - "/* c2 */\n" - ";\n" - "/* c1 */\n" - "/* c2 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(\n" - "// c1\n" - "// c2\n" - ")\n" - "// c1\n" - "// c2\n" - ";\n" - "// c1\n" - "// c2\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(\n" - " // c1\n" - " // c2\n" - ")\n" - "// c1\n" - "// c2\n" - ";\n" - "// c1\n" - "// c2\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(/* c1 */\n" - "/* c2 */)/* c1 */\n" - "/* c2 */;/* c1 */\n" - "/* c2 */\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ( /* c1 */\n" - "/* c2 */) /* c1 */\n" - "/* c2 */; /* c1 */\n" - "/* c2 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(// c1\n" - "/* c2 */)// c1\n" - "/* c2 */;// c1\n" - "/* c2 */\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ( // c1\n" - "/* c2 */) // c1\n" - "/* c2 */; // c1\n" - "/* c2 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(/* c1 */\n" - "/* c2 */\n" - "/* c3 */)/* c1 */\n" - "/* c2 */\n" - "/* c3 */;/* c1 */\n" - "/* c2 */\n" - "/* c3 */\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ( /* c1 */\n" - " /* c2 */\n" - "/* c3 */) /* c1 */\n" - "/* c2 */\n" - "/* c3 */; /* c1 */\n" - "/* c2 */\n" - "/* c3 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(/* c1 */\n" - "/* c2 */\n" - ")/* c1 */\n" - "/* c2 */\n" - ";/* c1 */\n" - "/* c2 */\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ( /* c1 */\n" - " /* c2 */\n" - ") /* c1 */\n" - "/* c2 */\n" - "; /* c1 */\n" - "/* c2 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(// c1\n" - "/* c2 */\n" - ")// c1\n" - "/* c2 */\n" - ";// c1\n" - "/* c2 */\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ( // c1\n" - " /* c2 */\n" - ") // c1\n" - "/* c2 */\n" - "; // c1\n" - "/* c2 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(/* c1 */\n" - "// c2\n" - ")/* c1 */\n" - "// c2\n" - ";/* c1 */\n" - "// c2\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ( /* c1 */\n" - " // c2\n" - ") /* c1 */\n" - "// c2\n" - "; /* c1 */\n" - "// c2\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(// c1\n" - "// c2\n" - ")// c1\n" - "// c2\n" - ";// c1\n" - "// c2\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ( // c1\n" - " // c2\n" - ") // c1\n" - " // c2\n" - "; // c1\n" - " // c2\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(/* c1 */\n" - "/* c2 */\n" - "/* c3 */\n" - ")/* c1 */\n" - "/* c2 */\n" - "/* c3 */\n" - ";/* c1 */\n" - "/* c2 */\n" - "/* c3 */\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ( /* c1 */\n" - " /* c2 */\n" - " /* c3 */\n" - ") /* c1 */\n" - "/* c2 */\n" - "/* c3 */\n" - "; /* c1 */\n" - "/* c2 */\n" - "/* c3 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(// c1\n" - "// c2\n" - "// c3\n" - ")// c1\n" - "// c2\n" - "// c3\n" - ";// c1\n" - "// c2\n" - "// c3\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ( // c1\n" - " // c2\n" - " // c3\n" - ") // c1\n" - " // c2\n" - " // c3\n" - "; // c1\n" - " // c2\n" - " // c3\n"}, - - // everywhere, with args - - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz/* c */(/* c */arg1/* c */,/* c */arg2/* c */)/* c */;/* c " - "*/\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz /* c */ ( /* c */\n" - " arg1 /* c */, /* c */\n" - " arg2 /* c */) /* c */; /* c */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz/* c1 */ /* c2 */(/* c1 */ /* c2 */arg1/* c1 */ /* c2 */,/* c1 " - "*/ /* c2 */arg2/* c1 */ /* c2 */)/* c1 */ /* c2 */;/* c1 */ /* c2 */\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz /* c1 */ /* c2 */ ( /* c1 */ /* c2 */\n" - " arg1 /* c1 */ /* c2 */, /* c1 */ /* c2 */\n" - " arg2 /* c1 */ /* c2 */) /* c1 */ /* c2 */; /* c1 */ /* c2 " - "*/\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz/* c */\n" - "(/* c */\n" - "arg1/* c */\n" - ",/* c */\n" - "arg2/* c */\n" - ")/* c */\n" - ";/* c */\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz /* c */\n" - " ( /* c */\n" - " arg1 /* c */\n" - " , /* c */\n" - " arg2 /* c */\n" - " ) /* c */\n" - "; /* c */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz/* c1 */ /* c2 */\n" - "(/* c1 */ /* c2 */\n" - "arg1/* c1 */ /* c2 */\n" - ",/* c1 */ /* c2 */\n" - "arg2/* c1 */ /* c2 */\n" - ")/* c1 */ /* c2 */\n" - ";/* c1 */ /* c2 */\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz /* c1 */ /* c2 */\n" - " ( /* c1 */ /* c2 */\n" - " arg1 /* c1 */ /* c2 */\n" - " , /* c1 */ /* c2 */\n" - " arg2 /* c1 */ /* c2 */\n" - " ) /* c1 */ /* c2 */\n" - "; /* c1 */ /* c2 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz// c\n" - "(// c\n" - "arg1// c\n" - ",// c\n" - "arg2// c\n" - ")// c\n" - ";// c\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz // c\n" - " ( // c\n" - " arg1 // c\n" - " , // c\n" - " arg2 // c\n" - " ) // c\n" - "; // c\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz/* c1 */ // c2\n" - "(/* c1 */ // c2\n" - "arg1/* c1 */ // c2\n" - ",/* c1 */ // c2\n" - "arg2/* c1 */ // c2\n" - ")/* c1 */ // c2\n" - ";/* c1 */ // c2\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz /* c1 */ // c2\n" - " ( /* c1 */ // c2\n" - " arg1 /* c1 */ // c2\n" - " , /* c1 */ // c2\n" - " arg2 /* c1 */ // c2\n" - " ) /* c1 */ // c2\n" - "; /* c1 */ // c2\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz\n" - "/* c */(\n" - "/* c */arg1\n" - "/* c */,\n" - "/* c */arg2\n" - "/* c */)\n" - "/* c */;\n" - "/* c */\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz\n" - " /* c */ (\n" - " /* c */ arg1\n" - " /* c */,\n" - " /* c */ arg2\n" - " /* c */)\n" - "/* c */;\n" - "/* c */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz\n" - "/* c1 */ /* c2 */(\n" - "/* c1 */ /* c2 */arg1\n" - "/* c1 */ /* c2 */,\n" - "/* c1 */ /* c2 */arg2\n" - "/* c1 */ /* c2 */)\n" - "/* c1 */ /* c2 */;\n" - "/* c1 */ /* c2 */\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz\n" - " /* c1 */ /* c2 */ (\n" - " /* c1 */ /* c2 */ arg1\n" - " /* c1 */ /* c2 */,\n" - " /* c1 */ /* c2 */ arg2\n" - " /* c1 */ /* c2 */)\n" - "/* c1 */ /* c2 */;\n" - "/* c1 */ /* c2 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz\n" - "/* c */\n" - "(\n" - "/* c */\n" - "arg1\n" - "/* c */\n" - ",\n" - "/* c */\n" - "arg2\n" - "/* c */\n" - ")\n" - "/* c */\n" - ";\n" - "/* c */\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz\n" - " /* c */\n" - " (\n" - " /* c */\n" - " arg1\n" - " /* c */\n" - " ,\n" - " /* c */\n" - " arg2\n" - " /* c */\n" - " )\n" - "/* c */\n" - ";\n" - "/* c */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz\n" - "/* c1 */ /* c2 */\n" - "(\n" - "/* c1 */ /* c2 */\n" - "arg1\n" - "/* c1 */ /* c2 */\n" - ",\n" - "/* c1 */ /* c2 */\n" - "arg2\n" - "/* c1 */ /* c2 */\n" - ")\n" - "/* c1 */ /* c2 */\n" - ";\n" - "/* c1 */ /* c2 */\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz\n" - " /* c1 */ /* c2 */\n" - " (\n" - " /* c1 */ /* c2 */\n" - " arg1\n" - " /* c1 */ /* c2 */\n" - " ,\n" - " /* c1 */ /* c2 */\n" - " arg2\n" - " /* c1 */ /* c2 */\n" - " )\n" - "/* c1 */ /* c2 */\n" - ";\n" - "/* c1 */ /* c2 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz\n" - "// c\n" - "(\n" - "// c\n" - "arg1\n" - "// c\n" - ",\n" - "// c\n" - "arg2\n" - "// c\n" - ")\n" - "// c\n" - ";\n" - "// c\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz\n" - " // c\n" - " (\n" - " // c\n" - " arg1\n" - " // c\n" - " ,\n" - " // c\n" - " arg2\n" - " // c\n" - " )\n" - "// c\n" - ";\n" - "// c\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz\n" - "/* c1 */ // c2\n" - "(\n" - "/* c1 */ // c2\n" - "arg1\n" - "/* c1 */ // c2\n" - ",\n" - "/* c1 */ // c2\n" - "arg2\n" - "/* c1 */ // c2\n" - ")\n" - "/* c1 */ // c2\n" - ";\n" - "/* c1 */ // c2\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz\n" - " /* c1 */ // c2\n" - " (\n" - " /* c1 */ // c2\n" - " arg1\n" - " /* c1 */ // c2\n" - " ,\n" - " /* c1 */ // c2\n" - " arg2\n" - " /* c1 */ // c2\n" - " )\n" - "/* c1 */ // c2\n" - ";\n" - "/* c1 */ // c2\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz\n" - "/* c1 */\n" - "/* c2 */\n" - "(\n" - "/* c1 */\n" - "/* c2 */\n" - "arg1\n" - "/* c1 */\n" - "/* c2 */\n" - ",\n" - "/* c1 */\n" - "/* c2 */\n" - "arg2\n" - "/* c1 */\n" - "/* c2 */\n" - ")\n" - "/* c1 */\n" - "/* c2 */\n" - ";\n" - "/* c1 */\n" - "/* c2 */\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz\n" - " /* c1 */\n" - " /* c2 */\n" - " (\n" - " /* c1 */\n" - " /* c2 */\n" - " arg1\n" - " /* c1 */\n" - " /* c2 */\n" - " ,\n" - " /* c1 */\n" - " /* c2 */\n" - " arg2\n" - " /* c1 */\n" - " /* c2 */\n" - " )\n" - "/* c1 */\n" - "/* c2 */\n" - ";\n" - "/* c1 */\n" - "/* c2 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz\n" - "// c1\n" - "// c2\n" - "(\n" - "// c1\n" - "// c2\n" - "arg1\n" - "// c1\n" - "// c2\n" - ",\n" - "// c1\n" - "// c2\n" - "arg2\n" - "// c1\n" - "// c2\n" - ")\n" - "// c1\n" - "// c2\n" - ";\n" - "// c1\n" - "// c2\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz\n" - " // c1\n" - " // c2\n" - " (\n" - " // c1\n" - " // c2\n" - " arg1\n" - " // c1\n" - " // c2\n" - " ,\n" - " // c1\n" - " // c2\n" - " arg2\n" - " // c1\n" - " // c2\n" - " )\n" - "// c1\n" - "// c2\n" - ";\n" - "// c1\n" - "// c2\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz/* c1 */\n" - "/* c2 */(/* c1 */\n" - "/* c2 */arg1/* c1 */\n" - "/* c2 */,/* c1 */\n" - "/* c2 */arg2/* c1 */\n" - "/* c2 */)/* c1 */\n" - "/* c2 */;/* c1 */\n" - "/* c2 */\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz /* c1 */\n" - " /* c2 */ ( /* c1 */\n" - " /* c2 */ arg1 /* c1 */\n" - " /* c2 */, /* c1 */\n" - " /* c2 */ arg2 /* c1 */\n" - " /* c2 */) /* c1 */\n" - "/* c2 */; /* c1 */\n" - "/* c2 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz// c1\n" - "/* c2 */(// c1\n" - "/* c2 */arg1// c1\n" - "/* c2 */,// c1\n" - "/* c2 */arg2// c1\n" - "/* c2 */)// c1\n" - "/* c2 */;// c1\n" - "/* c2 */\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz // c1\n" - " /* c2 */ ( // c1\n" - " /* c2 */ arg1 // c1\n" - " /* c2 */, // c1\n" - " /* c2 */ arg2 // c1\n" - " /* c2 */) // c1\n" - "/* c2 */; // c1\n" - "/* c2 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz/* c1 */\n" - "/* c2 */\n" - "/* c3 */(/* c1 */\n" - "/* c2 */\n" - "/* c3 */arg1/* c1 */\n" - "/* c2 */\n" - "/* c3 */,/* c1 */\n" - "/* c2 */\n" - "/* c3 */arg2/* c1 */\n" - "/* c2 */\n" - "/* c3 */)/* c1 */\n" - "/* c2 */\n" - "/* c3 */;/* c1 */\n" - "/* c2 */\n" - "/* c3 */\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz /* c1 */\n" - " /* c2 */\n" - " /* c3 */ ( /* c1 */\n" - " /* c2 */\n" - " /* c3 */ arg1 /* c1 */\n" - " /* c2 */\n" - " /* c3 */, /* c1 */\n" - " /* c2 */\n" - " /* c3 */ arg2 /* c1 */\n" - " /* c2 */\n" - " /* c3 */) /* c1 */\n" - "/* c2 */\n" - "/* c3 */; /* c1 */\n" - "/* c2 */\n" - "/* c3 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz/* c1 */\n" - "/* c2 */\n" - "(/* c1 */\n" - "/* c2 */\n" - "arg1/* c1 */\n" - "/* c2 */\n" - ",/* c1 */\n" - "/* c2 */\n" - "arg2/* c1 */\n" - "/* c2 */\n" - ")/* c1 */\n" - "/* c2 */\n" - ";/* c1 */\n" - "/* c2 */\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz /* c1 */\n" - " /* c2 */\n" - " ( /* c1 */\n" - " /* c2 */\n" - " arg1 /* c1 */\n" - " /* c2 */\n" - " , /* c1 */\n" - " /* c2 */\n" - " arg2 /* c1 */\n" - " /* c2 */\n" - " ) /* c1 */\n" - "/* c2 */\n" - "; /* c1 */\n" - "/* c2 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz// c1\n" - "/* c2 */\n" - "(// c1\n" - "/* c2 */\n" - "arg1// c1\n" - "/* c2 */\n" - ",// c1\n" - "/* c2 */\n" - "arg2// c1\n" - "/* c2 */\n" - ")// c1\n" - "/* c2 */\n" - ";// c1\n" - "/* c2 */\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz // c1\n" - " /* c2 */\n" - " ( // c1\n" - " /* c2 */\n" - " arg1 // c1\n" - " /* c2 */\n" - " , // c1\n" - " /* c2 */\n" - " arg2 // c1\n" - " /* c2 */\n" - " ) // c1\n" - "/* c2 */\n" - "; // c1\n" - "/* c2 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz/* c1 */\n" - "// c2\n" - "(/* c1 */\n" - "// c2\n" - "arg1/* c1 */\n" - "// c2\n" - ",/* c1 */\n" - "// c2\n" - "arg2/* c1 */\n" - "// c2\n" - ")/* c1 */\n" - "// c2\n" - ";/* c1 */\n" - "// c2\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz /* c1 */\n" - " // c2\n" - " ( /* c1 */\n" - " // c2\n" - " arg1 /* c1 */\n" - " // c2\n" - " , /* c1 */\n" - " // c2\n" - " arg2 /* c1 */\n" - " // c2\n" - " ) /* c1 */\n" - "// c2\n" - "; /* c1 */\n" - "// c2\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz// c1\n" - "// c2\n" - "(// c1\n" - "// c2\n" - "arg1// c1\n" - "// c2\n" - ",// c1\n" - "// c2\n" - "arg2// c1\n" - "// c2\n" - ")// c1\n" - "// c2\n" - ";// c1\n" - "// c2\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz // c1\n" - " // c2\n" - " ( // c1\n" - " // c2\n" - " arg1 // c1\n" - " // c2\n" - " , // c1\n" - " // c2\n" - " arg2 // c1\n" - " // c2\n" - " ) // c1\n" - " // c2\n" - "; // c1\n" - " // c2\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz/* c1 */\n" - "/* c2 */\n" - "/* c3 */\n" - "(/* c1 */\n" - "/* c2 */\n" - "/* c3 */\n" - "arg1/* c1 */\n" - "/* c2 */\n" - "/* c3 */\n" - ",/* c1 */\n" - "/* c2 */\n" - "/* c3 */\n" - "arg2/* c1 */\n" - "/* c2 */\n" - "/* c3 */\n" - ")/* c1 */\n" - "/* c2 */\n" - "/* c3 */\n" - ";/* c1 */\n" - "/* c2 */\n" - "/* c3 */\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz /* c1 */\n" - " /* c2 */\n" - " /* c3 */\n" - " ( /* c1 */\n" - " /* c2 */\n" - " /* c3 */\n" - " arg1 /* c1 */\n" - " /* c2 */\n" - " /* c3 */\n" - " , /* c1 */\n" - " /* c2 */\n" - " /* c3 */\n" - " arg2 /* c1 */\n" - " /* c2 */\n" - " /* c3 */\n" - " ) /* c1 */\n" - "/* c2 */\n" - "/* c3 */\n" - "; /* c1 */\n" - "/* c2 */\n" - "/* c3 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "$foobarbaz// c1\n" - "// c2\n" - "// c3\n" - "(// c1\n" - "// c2\n" - "// c3\n" - "arg1// c1\n" - "// c2\n" - "// c3\n" - ",// c1\n" - "// c2\n" - "// c3\n" - "arg2// c1\n" - "// c2\n" - "// c3\n" - ")// c1\n" - "// c2\n" - "// c3\n" - ";// c1\n" - "// c2\n" - "// c3\n", - "// verilog_syntax: parse-as-module-body\n" - "$foobarbaz // c1\n" - " // c2\n" - " // c3\n" - " ( // c1\n" - " // c2\n" - " // c3\n" - " arg1 // c1\n" - " // c2\n" - " // c3\n" - " , // c1\n" - " // c2\n" - " // c3\n" - " arg2 // c1\n" - " // c2\n" - " // c3\n" - " ) // c1\n" - " // c2\n" - " // c3\n" - "; // c1\n" - " // c2\n" - " // c3\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(/* c */arg1/* c */,/* c */arg2/* c */)/* c */;/* c */\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ( /* c */\n" - " arg1 /* c */, /* c */\n" - " arg2 /* c */) /* c */; /* c */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(/* c1 */ /* c2 */arg1/* c1 */ /* c2 */,/* c1 */ /* c2 " - "*/arg2/* c1 */ /* c2 */)/* c1 */ /* c2 */;/* c1 */ /* c2 */\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ( /* c1 */ /* c2 */\n" - " arg1 /* c1 */ /* c2 */, /* c1 */ /* c2 */\n" - " arg2 /* c1 */ /* c2 */) /* c1 */ /* c2 */; /* c1 */ /* c2 " - "*/\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(/* c */\n" - "arg1/* c */\n" - ",/* c */\n" - "arg2/* c */\n" - ")/* c */\n" - ";/* c */\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ( /* c */\n" - " arg1 /* c */\n" - " , /* c */\n" - " arg2 /* c */\n" - ") /* c */\n" - "; /* c */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(/* c1 */ /* c2 */\n" - "arg1/* c1 */ /* c2 */\n" - ",/* c1 */ /* c2 */\n" - "arg2/* c1 */ /* c2 */\n" - ")/* c1 */ /* c2 */\n" - ";/* c1 */ /* c2 */\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ( /* c1 */ /* c2 */\n" - " arg1 /* c1 */ /* c2 */\n" - " , /* c1 */ /* c2 */\n" - " arg2 /* c1 */ /* c2 */\n" - ") /* c1 */ /* c2 */\n" - "; /* c1 */ /* c2 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(// c\n" - "arg1// c\n" - ",// c\n" - "arg2// c\n" - ")// c\n" - ";// c\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ( // c\n" - " arg1 // c\n" - " , // c\n" - " arg2 // c\n" - ") // c\n" - "; // c\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(/* c1 */ // c2\n" - "arg1/* c1 */ // c2\n" - ",/* c1 */ // c2\n" - "arg2/* c1 */ // c2\n" - ")/* c1 */ // c2\n" - ";/* c1 */ // c2\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ( /* c1 */ // c2\n" - " arg1 /* c1 */ // c2\n" - " , /* c1 */ // c2\n" - " arg2 /* c1 */ // c2\n" - ") /* c1 */ // c2\n" - "; /* c1 */ // c2\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(\n" - "/* c */arg1\n" - "/* c */,\n" - "/* c */arg2\n" - "/* c */)\n" - "/* c */;\n" - "/* c */\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(\n" - " /* c */ arg1\n" - " /* c */,\n" - " /* c */ arg2\n" - "/* c */)\n" - "/* c */;\n" - "/* c */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(\n" - "/* c1 */ /* c2 */arg1\n" - "/* c1 */ /* c2 */,\n" - "/* c1 */ /* c2 */arg2\n" - "/* c1 */ /* c2 */)\n" - "/* c1 */ /* c2 */;\n" - "/* c1 */ /* c2 */\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(\n" - " /* c1 */ /* c2 */ arg1\n" - " /* c1 */ /* c2 */,\n" - " /* c1 */ /* c2 */ arg2\n" - "/* c1 */ /* c2 */)\n" - "/* c1 */ /* c2 */;\n" - "/* c1 */ /* c2 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(\n" - "/* c */\n" - "arg1\n" - "/* c */\n" - ",\n" - "/* c */\n" - "arg2\n" - "/* c */\n" - ")\n" - "/* c */\n" - ";\n" - "/* c */\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(\n" - " /* c */\n" - " arg1\n" - " /* c */\n" - " ,\n" - " /* c */\n" - " arg2\n" - " /* c */\n" - ")\n" - "/* c */\n" - ";\n" - "/* c */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(\n" - "/* c1 */ /* c2 */\n" - "arg1\n" - "/* c1 */ /* c2 */\n" - ",\n" - "/* c1 */ /* c2 */\n" - "arg2\n" - "/* c1 */ /* c2 */\n" - ")\n" - "/* c1 */ /* c2 */\n" - ";\n" - "/* c1 */ /* c2 */\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(\n" - " /* c1 */ /* c2 */\n" - " arg1\n" - " /* c1 */ /* c2 */\n" - " ,\n" - " /* c1 */ /* c2 */\n" - " arg2\n" - " /* c1 */ /* c2 */\n" - ")\n" - "/* c1 */ /* c2 */\n" - ";\n" - "/* c1 */ /* c2 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(\n" - "// c\n" - "arg1\n" - "// c\n" - ",\n" - "// c\n" - "arg2\n" - "// c\n" - ")\n" - "// c\n" - ";\n" - "// c\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(\n" - " // c\n" - " arg1\n" - " // c\n" - " ,\n" - " // c\n" - " arg2\n" - " // c\n" - ")\n" - "// c\n" - ";\n" - "// c\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(\n" - "/* c1 */ // c2\n" - "arg1\n" - "/* c1 */ // c2\n" - ",\n" - "/* c1 */ // c2\n" - "arg2\n" - "/* c1 */ // c2\n" - ")\n" - "/* c1 */ // c2\n" - ";\n" - "/* c1 */ // c2\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(\n" - " /* c1 */ // c2\n" - " arg1\n" - " /* c1 */ // c2\n" - " ,\n" - " /* c1 */ // c2\n" - " arg2\n" - " /* c1 */ // c2\n" - ")\n" - "/* c1 */ // c2\n" - ";\n" - "/* c1 */ // c2\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(\n" - "/* c1 */\n" - "/* c2 */\n" - "arg1\n" - "/* c1 */\n" - "/* c2 */\n" - ",\n" - "/* c1 */\n" - "/* c2 */\n" - "arg2\n" - "/* c1 */\n" - "/* c2 */\n" - ")\n" - "/* c1 */\n" - "/* c2 */\n" - ";\n" - "/* c1 */\n" - "/* c2 */\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(\n" - " /* c1 */\n" - " /* c2 */\n" - " arg1\n" - " /* c1 */\n" - " /* c2 */\n" - " ,\n" - " /* c1 */\n" - " /* c2 */\n" - " arg2\n" - " /* c1 */\n" - " /* c2 */\n" - ")\n" - "/* c1 */\n" - "/* c2 */\n" - ";\n" - "/* c1 */\n" - "/* c2 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(\n" - "// c1\n" - "// c2\n" - "arg1\n" - "// c1\n" - "// c2\n" - ",\n" - "// c1\n" - "// c2\n" - "arg2\n" - "// c1\n" - "// c2\n" - ")\n" - "// c1\n" - "// c2\n" - ";\n" - "// c1\n" - "// c2\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(\n" - " // c1\n" - " // c2\n" - " arg1\n" - " // c1\n" - " // c2\n" - " ,\n" - " // c1\n" - " // c2\n" - " arg2\n" - " // c1\n" - " // c2\n" - ")\n" - "// c1\n" - "// c2\n" - ";\n" - "// c1\n" - "// c2\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(/* c1 */\n" - "/* c2 */arg1/* c1 */\n" - "/* c2 */,/* c1 */\n" - "/* c2 */arg2/* c1 */\n" - "/* c2 */)/* c1 */\n" - "/* c2 */;/* c1 */\n" - "/* c2 */\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ( /* c1 */\n" - " /* c2 */ arg1 /* c1 */\n" - " /* c2 */, /* c1 */\n" - " /* c2 */ arg2 /* c1 */\n" - "/* c2 */) /* c1 */\n" - "/* c2 */; /* c1 */\n" - "/* c2 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(// c1\n" - "/* c2 */arg1// c1\n" - "/* c2 */,// c1\n" - "/* c2 */arg2// c1\n" - "/* c2 */)// c1\n" - "/* c2 */;// c1\n" - "/* c2 */\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ( // c1\n" - " /* c2 */ arg1 // c1\n" - " /* c2 */, // c1\n" - " /* c2 */ arg2 // c1\n" - "/* c2 */) // c1\n" - "/* c2 */; // c1\n" - "/* c2 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(/* c1 */\n" - "/* c2 */\n" - "/* c3 */arg1/* c1 */\n" - "/* c2 */\n" - "/* c3 */,/* c1 */\n" - "/* c2 */\n" - "/* c3 */arg2/* c1 */\n" - "/* c2 */\n" - "/* c3 */)/* c1 */\n" - "/* c2 */\n" - "/* c3 */;/* c1 */\n" - "/* c2 */\n" - "/* c3 */\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ( /* c1 */\n" - " /* c2 */\n" - " /* c3 */ arg1 /* c1 */\n" - " /* c2 */\n" - " /* c3 */, /* c1 */\n" - " /* c2 */\n" - " /* c3 */ arg2 /* c1 */\n" - " /* c2 */\n" - "/* c3 */) /* c1 */\n" - "/* c2 */\n" - "/* c3 */; /* c1 */\n" - "/* c2 */\n" - "/* c3 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(/* c1 */\n" - "/* c2 */\n" - "arg1/* c1 */\n" - "/* c2 */\n" - ",/* c1 */\n" - "/* c2 */\n" - "arg2/* c1 */\n" - "/* c2 */\n" - ")/* c1 */\n" - "/* c2 */\n" - ";/* c1 */\n" - "/* c2 */\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ( /* c1 */\n" - " /* c2 */\n" - " arg1 /* c1 */\n" - " /* c2 */\n" - " , /* c1 */\n" - " /* c2 */\n" - " arg2 /* c1 */\n" - " /* c2 */\n" - ") /* c1 */\n" - "/* c2 */\n" - "; /* c1 */\n" - "/* c2 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(// c1\n" - "/* c2 */\n" - "arg1// c1\n" - "/* c2 */\n" - ",// c1\n" - "/* c2 */\n" - "arg2// c1\n" - "/* c2 */\n" - ")// c1\n" - "/* c2 */\n" - ";// c1\n" - "/* c2 */\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ( // c1\n" - " /* c2 */\n" - " arg1 // c1\n" - " /* c2 */\n" - " , // c1\n" - " /* c2 */\n" - " arg2 // c1\n" - " /* c2 */\n" - ") // c1\n" - "/* c2 */\n" - "; // c1\n" - "/* c2 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(/* c1 */\n" - "// c2\n" - "arg1/* c1 */\n" - "// c2\n" - ",/* c1 */\n" - "// c2\n" - "arg2/* c1 */\n" - "// c2\n" - ")/* c1 */\n" - "// c2\n" - ";/* c1 */\n" - "// c2\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ( /* c1 */\n" - " // c2\n" - " arg1 /* c1 */\n" - " // c2\n" - " , /* c1 */\n" - " // c2\n" - " arg2 /* c1 */\n" - " // c2\n" - ") /* c1 */\n" - "// c2\n" - "; /* c1 */\n" - "// c2\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(// c1\n" - "// c2\n" - "arg1// c1\n" - "// c2\n" - ",// c1\n" - "// c2\n" - "arg2// c1\n" - "// c2\n" - ")// c1\n" - "// c2\n" - ";// c1\n" - "// c2\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ( // c1\n" - " // c2\n" - " arg1 // c1\n" - " // c2\n" - " , // c1\n" - " // c2\n" - " arg2 // c1\n" - " // c2\n" - ") // c1\n" - " // c2\n" - "; // c1\n" - " // c2\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(/* c1 */\n" - "/* c2 */\n" - "/* c3 */\n" - "arg1/* c1 */\n" - "/* c2 */\n" - "/* c3 */\n" - ",/* c1 */\n" - "/* c2 */\n" - "/* c3 */\n" - "arg2/* c1 */\n" - "/* c2 */\n" - "/* c3 */\n" - ")/* c1 */\n" - "/* c2 */\n" - "/* c3 */\n" - ";/* c1 */\n" - "/* c2 */\n" - "/* c3 */\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ( /* c1 */\n" - " /* c2 */\n" - " /* c3 */\n" - " arg1 /* c1 */\n" - " /* c2 */\n" - " /* c3 */\n" - " , /* c1 */\n" - " /* c2 */\n" - " /* c3 */\n" - " arg2 /* c1 */\n" - " /* c2 */\n" - " /* c3 */\n" - ") /* c1 */\n" - "/* c2 */\n" - "/* c3 */\n" - "; /* c1 */\n" - "/* c2 */\n" - "/* c3 */\n"}, - {"// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ(// c1\n" - "// c2\n" - "// c3\n" - "arg1// c1\n" - "// c2\n" - "// c3\n" - ",// c1\n" - "// c2\n" - "// c3\n" - "arg2// c1\n" - "// c2\n" - "// c3\n" - ")// c1\n" - "// c2\n" - "// c3\n" - ";// c1\n" - "// c2\n" - "// c3\n", - "// verilog_syntax: parse-as-module-body\n" - "`FOOBARBAZ( // c1\n" - " // c2\n" - " // c3\n" - " arg1 // c1\n" - " // c2\n" - " // c3\n" - " , // c1\n" - " // c2\n" - " // c3\n" - " arg2 // c1\n" - " // c2\n" - " // c3\n" - ") // c1\n" - " // c2\n" - " // c3\n" - "; // c1\n" - " // c2\n" - " // c3\n"}, - {"module indent();\n" - " reg a;\n" - " reg [32:0] b;\n" - " wire c;\n" - " wire d = e ? kFoo : kBar;\n" - "endmodule\n", - "module indent ();\n" - " reg a;\n" - " reg [32:0] b;\n" - " wire c;\n" - " wire d = e ? kFoo : kBar;\n" - "endmodule\n"}, - - {"class C; T1 b; logic [$] a; T1 [$] c; endclass\n", - "class C;\n" - " T1 b;\n" - " logic [$] a;\n" - " T1 [$] c;\n" - "endclass\n"}, - {"class C;\n" - " T1 b; //test\n" - " logic [$] a; //test\n" - " T1 [$] c; //test\n" - "endclass\n", - "class C;\n" - " T1 b; //test\n" - " logic [$] a; //test\n" - " T1 [$] c; //test\n" - "endclass\n"}, - {"class C;\n" - " T1\n" - " b;\n" - " logic\n" - " [$]\n" - " a;\n" - " T1\n" - " [$]\n" - " c;\n" - "endclass\n", - "class C;\n" - " T1 b;\n" - " logic [$] a;\n" - " T1 [$] c;\n" - "endclass\n"}, - {"class C;\n" - " logic/*t*/ [0 : 1] /*t*/\n" - " a;/*t*/\n" - " T1/*t*/[0 : 1]/*t*/\n" - " c;/*t*/\n" - "endclass\n", - "class C;\n" - " logic/*t*/ [0 : 1] /*t*/ a; /*t*/\n" - " T1/*t*/ [0 : 1] /*t*/ c; /*t*/\n" - "endclass\n"}, - {"always @(*/*t*/) begin\n" - "end\n", - "always @(* /*t*/) begin\n" - "end\n"}, - {"always @(/*t*/*) begin\n" - "end\n", - "always @( /*t*/ *) begin\n" - "end\n"}, - {"always @(/*t*/*/*t*/) begin\n" - "end\n", - "always @( /*t*/ * /*t*/) begin\n" - "end\n"}, - {"always @(*) begin\n" - "end\n", - "always @(*) begin\n" - "end\n"}, - {"always @(* ) begin\n" - "end\n", - "always @(*) begin\n" - "end\n"}, - {"always @( *) begin\n" - "end\n", - "always @(*) begin\n" - "end\n"}, - {"always @( * ) begin\n" - "end\n", - "always @(*) begin\n" - "end\n"}, - {"always @( /*t*/ * /*t*/ ) begin\n" - "end\n", - "always @( /*t*/ * /*t*/) begin\n" - "end\n"}, - { - // Don't touch verilog_format:off region #1538 - R"( -module testcode; - // verilog_format: off - assign a = b - & c; - // verilog_format: on - assign e = d; -endmodule -)", - R"( -module testcode; - // verilog_format: off - assign a = b - & c; - // verilog_format: on - assign e = d; -endmodule -)", - - }, - - // ----------------------------------------------------------------- }; -// Tests that formatter produces expected results, end-to-end. -TEST(FormatterEndToEndTest, VerilogFormatTest) { - // Use a fixed style. - FormatStyle style; - style.column_limit = 40; - style.indentation_spaces = 2; - style.wrap_spaces = 4; - for (const auto &test_case : kFormatterTestCases) { - VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; - std::ostringstream stream; - const auto status = - FormatVerilog(test_case.input, "<filename>", style, stream); - // Require these test cases to be valid. - EXPECT_OK(status) << status.message(); - EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; - } -} - -TEST(FormatterEndToEndTest, AutoInferAlignment) { - static constexpr FormatterTestCase kTestCases[] = { - {"", ""}, - {"\n", "\n"}, - {"class cc ;\n" - "endclass:cc\n", - "class cc;\n" - "endclass : cc\n"}, - - // module port declarations - {"module pd(\n" - "input wire foo,\n" - "output reg bar\n" - ");\n" - "endmodule:pd\n", - "module pd (\n" - " input wire foo,\n" // flush-left vs. align are similar enough, - " output reg bar\n" // so automatic policy will align. - ");\n" - "endmodule : pd\n"}, - {"module pd(\n" - "input foo_pkg::baz_t foo,\n" - "output reg bar\n" - ");\n" - "endmodule:pd\n", - "module pd (\n" - " input foo_pkg::baz_t foo,\n" // alignment would add too many spaces - " output reg bar\n" // so infer intent to flush-left. - ");\n" - "endmodule : pd\n"}, - {"module pd(\n" - "input foo_pkg::baz_t foo,\n" - "output reg bar\n" // user injects 4 excess spaces here ... - ");\n" - "endmodule:pd\n", - "module pd (\n" - " input foo_pkg::baz_t foo,\n" - " output reg bar\n" // ... and triggers alignment. - ");\n" - "endmodule : pd\n"}, - {"module pd(\n" - "`ifdef FAA\n" // inside preprocessing conditional - "input baaaz_t foo,\n" - "output reg bar\n" // user injects 4 excess spaces here ... - "`endif\n" - ");\n" - "endmodule:pd\n", - "module pd (\n" - "`ifdef FAA\n" - " input baaaz_t foo,\n" - " output reg bar\n" // ... and triggers alignment. - "`endif\n" - ");\n" - "endmodule : pd\n"}, - {"module pd(\n" - "`ifdef FAA\n" // inside preprocessing conditional - "input baaaz_t foo,\n" - "`else\n" - "output reg bar\n" // user injects 4 excess spaces here ... - "`endif\n" - ");\n" - "endmodule:pd\n", - "module pd (\n" - "`ifdef FAA\n" - " input baaaz_t foo,\n" // aligned - "`else\n" // aligned across preprocessing directives - " output reg bar\n" // ... and triggers alignment. - "`endif\n" - ");\n" - "endmodule : pd\n"}, - {"module pd(\n" - "input logic [31:0] bus,\n" - "input logic [7:0] bus2,\n" - "`ifdef FAA\n" // inside preprocessing conditional - "input baaaz_t foo,\n" - "`else\n" - "output reg bar,\n" // user injects 4 excess spaces here ... - "`endif\n" - "output out_t zout1,\n" - "output out_t zout2\n" - ");\n" - "endmodule:pd\n", - "module pd (\n" - " input logic [31:0] bus,\n" // treated as one large group - " input logic [ 7:0] bus2,\n" - "`ifdef FAA\n" - " input baaaz_t foo,\n" // aligned - "`else\n" // aligned across preprocessing directives - " output reg bar,\n" // ... and triggers alignment. - "`endif\n" - " output out_t zout1,\n" - " output out_t zout2\n" - ");\n" - "endmodule : pd\n"}, - {"module pd(\n" - "input logic [7:0] bus2,\n" - "`ifndef FAA\n" // inside preprocessing conditional - "input logic [31:0] bus,\n" - "input baaaz_t foo,\n" - "`elsif BLA\n" - "output reg bar,\n" // user injects 4 excess spaces here ... - "output out_t zout1,\n" - "`endif\n" - "output out_t zout2\n" - ");\n" - "endmodule:pd\n", - "module pd (\n" - " input logic [ 7:0] bus2,\n" - "`ifndef FAA\n" - " input logic [31:0] bus,\n" // treated as one large group - " input baaaz_t foo,\n" // aligned - "`elsif BLA\n" // aligned across preprocessing directives - " output reg bar,\n" // ... and triggers alignment. - " output out_t zout1,\n" - "`endif\n" - " output out_t zout2\n" - ");\n" - "endmodule : pd\n"}, - {// data declaration and net declaration in ports - "module m(\n" - "logic [x:y]a ,\n" // packed dimensions, induce alignment - "wire [pp:qq] [e:f]b\n" // packed dimensions, 2D - ") ;\n" - "endmodule\n", - "module m (\n" - " logic [ x:y] a,\n" - " wire [pp:qq][e:f] b\n" - ");\n" - "endmodule\n"}, - {// used-defined data declarations in ports - "module m(\n" - "a::bb [x:y]a ,\n" // packed dimensions, induce alignment - "c#(d,e) [pp:qq] [e:f]b\n" // packed dimensions, 2D - ") ;\n" - "endmodule\n", - "module m (\n" - " a::bb [ x:y] a,\n" - " c#(d, e) [pp:qq][e:f] b\n" - ");\n" - "endmodule\n"}, - - // named parameter arguments - {"module mm ;\n" - "foo #(\n" - ".a(a),\n" - ".bb(bb)\n" - ")bar( );\n" - "endmodule:mm\n", - "module mm;\n" - " foo #(\n" - " .a (a),\n" // align doesn't add too many spaces, so align - " .bb(bb)\n" - " ) bar ();\n" - "endmodule : mm\n"}, - {"module mm ;\n" - "foo #(\n" - ".a(a),\n" - ".bbcccc(bb)\n" - ")bar( );\n" - "endmodule:mm\n", - "module mm;\n" - " foo #(\n" - " .a(a),\n" // align would add too many spaces, so flush-left - " .bbcccc(bb)\n" - " ) bar ();\n" - "endmodule : mm\n"}, - {"module mm ;\n" - "foo #(\n" - ".a(a ),\n" // user manually triggers alignment with excess spaces - ".bbcccc(bb)\n" - ")bar( );\n" - "endmodule:mm\n", - "module mm;\n" - " foo #(\n" - " .a (a),\n" // induced alignment - " .bbcccc(bb)\n" - " ) bar ();\n" - "endmodule : mm\n"}, - {"module mm ;\n" - "foo #(\n" - "//c1\n" // with comments (indented but not aligned) - ".a(a ),\n" // user manually triggers alignment with excess spaces - "//c2\n" - ".bbcccc(bb)\n" - "//c3\n" - ")bar( );\n" - "endmodule:mm\n", - "module mm;\n" - " foo #(\n" - " //c1\n" - " .a (a),\n" // induced alignment - " //c2\n" - " .bbcccc(bb)\n" - " //c3\n" - " ) bar ();\n" - "endmodule : mm\n"}, - {"module mm ;\n" - "foo #(\n" - ".a( (1 +2)),\n" // excess spaces, testing extra parentheses - ".bbcccc((c*d)+(e*f))\n" - ")bar( );\n" - "endmodule:mm\n", - "module mm;\n" - " foo #(\n" - " .a ((1 + 2)),\n" // induced alignment - " .bbcccc((c * d) + (e * f))\n" - " ) bar ();\n" - "endmodule : mm\n"}, - - // named port connections - {"module mm ;\n" - "foo bar(\n" - ".a(a),\n" - ".bb(bb)\n" - ");\n" - "endmodule:mm\n", - "module mm;\n" - " foo bar (\n" - " .a (a),\n" // align doesn't add too many spaces, so align - " .bb(bb)\n" - " );\n" - "endmodule : mm\n"}, - {"module mm ;\n" - "foo bar(\n" - ".a(a),\n" - ".bbbbbb(bb)\n" - ");\n" - "endmodule:mm\n", - "module mm;\n" - " foo bar (\n" - " .a(a),\n" // align would add too many spaces, so flush-left - " .bbbbbb(bb)\n" - " );\n" - "endmodule : mm\n"}, - {"module mm ;\n" - "foo bar(\n" - ".a (a),\n" // user manually triggers alignment with excess spaces - ".bbbbbb(bb)\n" - ");\n" - "endmodule:mm\n", - "module mm;\n" - " foo bar (\n" - " .a (a),\n" // alignment fixed - " .bbbbbb(bb)\n" - " );\n" - "endmodule : mm\n"}, - - // net variable declarations - {"module nn;\n" - "wire wwwww;\n" - "logic lll;\n" - "endmodule : nn\n", - "module nn;\n" - " wire wwwww;\n" // alignment adds few spaces, so align - " logic lll;\n" - "endmodule : nn\n"}, - {"module nn;\n" - "wire wwwww;\n" - "foo_pkg::baz_t lll;\n" - "endmodule : nn\n", - "module nn;\n" - " wire wwwww;\n" // alignment adds too many spaces, so flush-left - " foo_pkg::baz_t lll;\n" - "endmodule : nn\n"}, - {"module nn;\n" - "wire wwwww;\n" // user injects spaces to trigger alignment - "foo_pkg::baz_t lll;\n" - "endmodule : nn\n", - "module nn;\n" - " wire wwwww;\n" // ... and gets alignment - " foo_pkg::baz_t lll;\n" - "endmodule : nn\n"}, - {// data/net declarations as generate items (conditional) - "module nn;\n" - "if (cc)begin:fff\n" - "wire wwwww;\n" - "logic lll;\n" - "end:fff\n" - "endmodule : nn\n", - "module nn;\n" - " if (cc) begin : fff\n" - " wire wwwww;\n" // alignment adds few spaces, so align - " logic lll;\n" - " end : fff\n" - "endmodule : nn\n"}, - - // continuous assignments - {"module m_assign;\n" - "assign foo = 1'b1;\n" // alignment adds few spaces, so align - "assign baar = 1'b0;\n" - "endmodule\n", - "module m_assign;\n" - " assign foo = 1'b1;\n" // aligned - " assign baar = 1'b0;\n" - "endmodule\n"}, - {"module m_assign;\n" - "assign foo = 1'b1;\n" // alignment adds too many spaces, so - // flush-left - "assign baaaaaar = 1'b0;\n" - "endmodule\n", - "module m_assign;\n" - " assign foo = 1'b1;\n" // flush-left - " assign baaaaaar = 1'b0;\n" - "endmodule\n"}, - {"module m_assign;\n" - "assign foo = 1'b1;\n" // induce alignment with excess spaces - "assign baaaaaar = 1'b0;\n" - "endmodule\n", - "module m_assign;\n" - " assign foo = 1'b1;\n" // aligned - " assign baaaaaar = 1'b0;\n" - "endmodule\n"}, - {// currently, does not assign across ifdefs - "module m_assign;\n" - "`ifdef FOO\n" - "assign foo = 1'b1;\n" // induce alignment with excess spaces - "assign baaaaaar = 1'b0;\n" - "`else\n" - "assign zooo = 2'b11;\n" - "assign yoo = 2'b00;\n" - "`endif\n" - "endmodule\n", - "module m_assign;\n" - "`ifdef FOO\n" - " assign foo = 1'b1;\n" // aligned - " assign baaaaaar = 1'b0;\n" - "`else\n" // aligned separately above/below - " assign zooo = 2'b11;\n" // aligned - " assign yoo = 2'b00;\n" // aligned - "`endif\n" - "endmodule\n"}, - {// mixed net declaration and continuous assignment, both groups aligned - "module m_assign;\n" - "wire wwwww;\n" // induce alignment - "foo_pkg::baz_t lll;\n" - "assign foo = 1'b1;\n" // induce alignment - "assign baaaaaar = 1'b0;\n" - "endmodule\n", - "module m_assign;\n" - " wire wwwww;\n" // aligned - " foo_pkg::baz_t lll;\n" - " assign foo = 1'b1;\n" // aligned - " assign baaaaaar = 1'b0;\n" - "endmodule\n"}, - {// continuous assignments as generate items (conditional) - "module m_assign;\n" - "if (xy) begin\n" - "assign foo = 1'b0;\n" // align: adds few spaces - "assign baaar = 1'b1;\n" - "end else begin\n" - "assign goo = 1'b1;\n" // induce alignment with excess spaces - "assign zaaaaaar = 1'b0;\n" - "end\n" - "endmodule\n", - "module m_assign;\n" - " if (xy) begin\n" - " assign foo = 1'b0;\n" // aligned - " assign baaar = 1'b1;\n" - " end else begin\n" - " assign goo = 1'b1;\n" // induce alignment with excess spaces - " assign zaaaaaar = 1'b0;\n" - " end\n" - "endmodule\n"}, - {// continuous assignments as generate items (loop) - "module m_assign;\n" - "for(genvar i=0; i<k; ++i ) begin\n" - "assign foo = 1'b0;\n" // align: adds few spaces - "assign baaar = 1'b1;\n" - "end\n" - "endmodule\n", - "module m_assign;\n" - " for (genvar i = 0; i < k; ++i) begin\n" - " assign foo = 1'b0;\n" // aligned - " assign baaar = 1'b1;\n" - " end\n" - "endmodule\n"}, - {// continuous assignments as generate items (case) - "module m_assign;\n" - "case (c)\n" - "jk:begin\n" - "assign foo = 1'b0;\n" // align: adds few spaces - "assign baaar = 1'b1;\n" - "end\n" - "endcase\n" - "endmodule\n", - "module m_assign;\n" - " case (c)\n" - " jk: begin\n" - " assign foo = 1'b0;\n" // aligned - " assign baaar = 1'b1;\n" - " end\n" - " endcase\n" - "endmodule\n"}, - {// continuous assignment with comment - "module m;\n" - "// comment1\n" - "assign aaaaa = (bbbbb != ccccc) &\n" - "// comment2\n" - "(ddddd | (eeeee & ffffff));\n" - "endmodule\n", - "module m;\n" - " // comment1\n" - " assign aaaaa = (bbbbb != ccccc) &\n" - " // comment2\n" - " (ddddd | (eeeee & ffffff));\n" - "endmodule\n"}, - - // net/variable assignments: blocking and nonblocking - {"module ma ;\n" - "initial begin\n" - "aa = b;\n" - "c = 1'b0;\n" - "end\n" - "endmodule\n", - "module ma;\n" - " initial begin\n" - " aa = b;\n" - " c = 1'b0;\n" // only one space to align - " end\n" - "endmodule\n"}, - {"function void fa ;\n" - "c = 1'b0;\n" - "aa = b;\n" - "endfunction\n", - "function void fa;\n" - " c = 1'b0;\n" // only one space to align - " aa = b;\n" - "endfunction\n"}, - {"task ta ; \n" - "aa = b;\n" - "c = 1'b0;\n" - "endtask\n", - "task ta;\n" - " aa = b;\n" - " c = 1'b0;\n" // only one space to align - "endtask\n"}, - {"module ma ;\n" - "always@( posedge clk) begin\n" - "aaa <= b;\n" - "c <= 1'b0;\n" - "end\n" - "endmodule\n", - "module ma;\n" - " always @(posedge clk) begin\n" - " aaa <= b;\n" - " c <= 1'b0;\n" // only two spaces to align - " end\n" - "endmodule\n"}, - {"function int fa ;\n" - "c <= 1'b0;\n" - "aa <= b;\n" - "return 0 ;\n" - "endfunction\n", - "function int fa;\n" - " c <= 1'b0;\n" // only one space to align - " aa <= b;\n" - " return 0;\n" - "endfunction\n"}, - {"task ta ; \n" - "$display (\"hello\" );\n" - "aa <= b;\n" - "c <= 1'b0;\n" - "endtask\n", - "task ta;\n" - " $display(\"hello\");\n" - " aa <= b;\n" - " c <= 1'b0;\n" // only one space to align - "endtask\n"}, - {// mixed blocking and nonblocking assignments - "module ma ;\n" - "always@( posedge clk) begin\n" - "aaaaa = b;\n" - "ccc = 1'b0;\n" - "aaa <= b;\n" - "c <= 1'b0;\n" - "end\n" - "endmodule\n", - "module ma;\n" - " always @(posedge clk) begin\n" - " aaaaa = b;\n" - " ccc = 1'b0;\n" // only two spaces to align - " aaa <= b;\n" - " c <= 1'b0;\n" // only two spaces to align (separate group) - " end\n" - "endmodule\n"}, - {"task ta ; \n" - "aa <= b;\n" - "c <= 1'b0;\n" - "$display (\"hello\" );\n" // separates above/below alignment groups - "zzaa <= b;\n" - "zzc <= 1'b0;\n" - "endtask\n", - "task ta;\n" - " aa <= b;\n" - " c <= 1'b0;\n" // only one space to align - " $display(\"hello\");\n" - " zzaa <= b;\n" - " zzc <= 1'b0;\n" // only one space to align - "endtask\n"}, - {"task ta ; \n" - "$display (\"hello\" );\n" - "aaaaa <= b;\n" - "c <= 1'b0;\n" // need too many spaces to align - "endtask\n", - "task ta;\n" - " $display(\"hello\");\n" - " aaaaa <= b;\n" - " c <= 1'b0;\n" // so keep flush-left - "endtask\n"}, - {"function void fa ; \n" - "$display (\"hello\" );\n" - "aaaaa = b;\n" - "c = 1'b0;\n" // need too many spaces to align - "endfunction\n", - "function void fa;\n" - " $display(\"hello\");\n" - " aaaaa = b;\n" - " c = 1'b0;\n" // so keep flush-left - "endfunction\n"}, - {"module ma ;\n" - "always@( posedge clk) begin\n" - "aaaxx <= b;\n" - "c <= 1'b0;\n" // need too many spaces to align - "end\n" - "endmodule\n", - "module ma;\n" - " always @(posedge clk) begin\n" - " aaaxx <= b;\n" - " c <= 1'b0;\n" // so keep flush-left - " end\n" - "endmodule\n"}, - {"module ma ;\n" - "always@( posedge clk) begin\n" - "aaaxx <= b ;\n" // inject 4 spaces to induce alignment - "c <= 1'b0;\n" - "end\n" - "endmodule\n", - "module ma;\n" - " always @(posedge clk) begin\n" - " aaaxx <= b;\n" - " c <= 1'b0;\n" // induced alignment - " end\n" - "endmodule\n"}, - {"module ma ;\n" - "always@( posedge clk) begin\n" - "aaaxx <= b ;\n" // inject 4 spaces to induce alignment - "//comment\n" - "c <= 1'b0;\n" - "end\n" - "endmodule\n", - "module ma;\n" - " always @(posedge clk) begin\n" - " aaaxx <= b;\n" - " //comment\n" // ignored within alignment group - " c <= 1'b0;\n" // induced alignment - " end\n" - "endmodule\n"}, - - // local variable declarations as statements - {"task tt ;\n" - "int foo;\n" // only 2 spaces needed to align - "bar_t baz;\n" - "endtask\n", - "task tt;\n" - " int foo;\n" // aligned - " bar_t baz;\n" - "endtask\n"}, - {"function ff ;\n" - "bar_t baz;\n" - "int foo;\n" // only 2 spaces needed to align - "endfunction\n", - "function ff;\n" - " bar_t baz;\n" - " int foo;\n" // aligned - "endfunction\n"}, - {"task tt ;\n" - "int foo;\n" // too many spaces needed to align - "baaaar_t baz;\n" - "endtask\n", - "task tt;\n" - " int foo;\n" // so flush-left - " baaaar_t baz;\n" - "endtask\n"}, - {"function ff ;\n" - "baaaar_t baz;\n" - "int foo;\n" // too many spaces needed to align - "endfunction\n", - "function ff;\n" - " baaaar_t baz;\n" - " int foo;\n" // so flush-left - "endfunction\n"}, - {"task tt ;\n" - "int foo;\n" // injected spaces to induce alignment - "baaaar_t baz;\n" - "endtask\n", - "task tt;\n" - " int foo;\n" // aligned - " baaaar_t baz;\n" - "endtask\n"}, - {"function ff ;\n" - "baaaar_t baz ;\n" // injected spaces to induce alignment - "int foo;\n" - "endfunction\n", - "function ff;\n" - " baaaar_t baz;\n" - " int foo;\n" // so aligned - "endfunction\n"}, - - // formal parameters - {"module pp #(\n" - "int W,\n" - "type T\n" - ") ();\n" - "endmodule : pp\n", - "module pp #(\n" - " int W,\n" // alignment adds few spaces, so do it - " type T\n" - ") ();\n" - "endmodule : pp\n"}, - {"module pp #(\n" - "int W,\n" - "int[xx:yy] T\n" - ") ();\n" - "endmodule : pp\n", - "module pp #(\n" - " int W,\n" // alignment adds many spaces, so flush-left - " int [xx:yy] T\n" - ") ();\n" - "endmodule : pp\n"}, - {"module pp #(\n" - "int W,\n" - "int[xx:yy] T\n" // user injected spaces intentionally - ") ();\n" - "endmodule : pp\n", - "module pp #(\n" - " int W,\n" // ... trigger alignment - " int [xx:yy] T\n" - ") ();\n" - "endmodule : pp\n"}, - - // class member variables - {"class cc ;\n" - "int my_int;\n" - "bar_t my_bar;\n" - "endclass:cc\n", - "class cc;\n" - " int my_int;\n" // align doesn't add too many spaces, so align - " bar_t my_bar;\n" - "endclass : cc\n"}, - {"class cc ;\n" - "int my_int;\n" - "foo_pkg::bar_t my_bar;\n" - "endclass:cc\n", - "class cc;\n" - " int my_int;\n" // align would add too many spaces, so flush-left - " foo_pkg::bar_t my_bar;\n" - "endclass : cc\n"}, - {"class cc ;\n" - "int my_int;\n" // intentional excessive spaces, trigger alignment - "foo_pkg::bar_t my_bar;\n" - "endclass:cc\n", - "class cc;\n" - " int my_int;\n" - " foo_pkg::bar_t my_bar;\n" - "endclass : cc\n"}, - {"class cc ;\n" - "int my_int;\n" // unable to infer user's intent, so preserve - "foo_pkg::bar_t my_bar;\n" - "endclass:cc\n", - "class cc;\n" - " int my_int;\n" // ... but still indent - " foo_pkg::bar_t my_bar;\n" - "endclass : cc\n"}, - - // case item test cases - {// small difference between flush-left and align, so align - "function f; case (x)kZZZZ :if( b )break; default :return 2;" - "endcase endfunction\n", - "function f;\n" - " case (x)\n" - " kZZZZ: if (b) break;\n" // aligned, only adds 2 spaces - " default: return 2;\n" - " endcase\n" - "endfunction\n"}, - {// small error relative to flush-left, so flush-left - "function f; case (x)kZ :if( b )break; default :return 2;" - "endcase endfunction\n", - "function f;\n" - " case (x)\n" - " kZ: if (b) break;\n" // flush-left - " default: return 2;\n" - " endcase\n" - "endfunction\n"}, - {// intentional spacing error (delta=4) induces alignment - "function f; case (x)kZ :if( b )break; default :return 2;" - "endcase endfunction\n", - "function f;\n" - " case (x)\n" - " kZ: if (b) break;\n" - " default: return 2;\n" - " endcase\n" - "endfunction\n"}, - {// induced alignment, with ignored comments - "function f; case (x)kZ :if( b )break; \n//c1\n kXX: g = f; " - "\n//c2\ndefault :return 2;" - "endcase endfunction\n", - "function f;\n" - " case (x)\n" - " kZ: if (b) break;\n" - " //c1\n" - " kXX: g = f;\n" - " //c2\n" - " default: return 2;\n" - " endcase\n" - "endfunction\n"}, - {// induced alignment, ignore multiline case item in the middle - "function f; case (x)" - "kZ :if( b )break; " - "kYY :return 2;" // excess spaces induce alignment - " kXXXXXXXXX: begin end" // multi-line, ignored - " kWWWWW: cc = 23;\n" - " kVVV: cd = 24;\n" - "endcase endfunction\n", - "function f;\n" - " case (x)\n" - " kZ: if (b) break;\n" - " kYY: return 2;\n" - " kXXXXXXXXX: begin\n" // separates above/below groups - " end\n" - " kWWWWW: cc = 23;\n" - " kVVV: cd = 24;\n" // aligned - " endcase\n" - "endfunction\n"}, - {// induced alignment, ignore multiline case item in the middle - "function f; case (x)" - "kZ :if( b )break; " - "kYY :return 2;" // excess spaces induce alignment - " kXXXXXXXXX: if(w)begin end" // multi-line, ignored - " kWWWWW: cc = 23;\n" - " kVVV: cd = 24;\n" - "endcase endfunction\n", - "function f;\n" - " case (x)\n" - " kZ: if (b) break;\n" - " kYY: return 2;\n" - " kXXXXXXXXX:\n" // TODO(fangism): allow this to merge with if() - // else indent the following two lines - " if (w) begin\n" // separates above/below groups - " end\n" - " kWWWWW: cc = 23;\n" - " kVVV: cd = 24;\n" // aligned - " endcase\n" - "endfunction\n"}, - {// induced alignment, ignore multiline case item in the middle - "task t; case (x)" - "kZ :if( b )break; " - "kYY :return 2;" // excess spaces induce alignment - " kXXXXXXXXX: fork join" // multi-line, ignored - " kWWWWW: cc = 23;\n" - " kVVV: cd = 24;\n" - "endcase endtask\n", - "task t;\n" - " case (x)\n" - " kZ: if (b) break;\n" - " kYY: return 2;\n" - " kXXXXXXXXX:\n" // TODO(fangism): allow this to merge with fork - // else indent the following two lines - " fork\n" // separates above/below groups - " join\n" - " kWWWWW: cc = 23;\n" - " kVVV: cd = 24;\n" // aligned - " endcase\n" - "endtask\n"}, - {// case-inside: small difference between flush-left and align, so align - "function f; case (x)inside [0:3] :yy=zzz; [4:11] :yy=zz;" - "endcase endfunction\n", - "function f;\n" - " case (x) inside\n" - " [0 : 3]: yy = zzz;\n" // aligned, only adds 1 spaces - " [4 : 11]: yy = zz;\n" - " endcase\n" - "endfunction\n"}, - {// case-inside: align with comments - "function f; case (x)inside \n//c1\n[0:3] :yy=zzz;\n//c2\n" - " [4:11] :yy=zz;\n//c3\n" - "endcase endfunction\n", - "function f;\n" - " case (x) inside\n" - " //c1\n" - " [0 : 3]: yy = zzz;\n" // aligned, only adds 1 spaces - " //c2\n" - " [4 : 11]: yy = zz;\n" - " //c3\n" - " endcase\n" - "endfunction\n"}, - {// case-inside: flush left - "function f; case (x)inside [0:3] :yy=zzz; [4:999999] :yy=zz;" - "endcase endfunction\n", - "function f;\n" - " case (x) inside\n" - " [0 : 3]: yy = zzz;\n" // flush-left - " [4 : 999999]: yy = zz;\n" - " endcase\n" - "endfunction\n"}, - {// case-inside: induce alignment - "function f; case (x)inside [0:3 ] :yy=zzz; [4:999999] :yy=zz;" - "endcase endfunction\n", - "function f;\n" - " case (x) inside\n" - " [0 : 3]: yy = zzz;\n" // aligned - " [4 : 999999]: yy = zz;\n" - " endcase\n" - "endfunction\n"}, - {// case-generate: align would add few spaces, so align - "module mc ; case (x)kZ : gg h(); kXYY :j kk();" - "endcase endmodule\n", - "module mc;\n" - " case (x)\n" - " kZ: gg h ();\n" // align - " kXYY: j kk ();\n" - " endcase\n" - "endmodule\n"}, - {// case-generate + comment: align would add few spaces, so align - "module mc ; case (x)kZ : gg h(); \n//c1\n kXYY :j kk();" - "endcase endmodule\n", - "module mc;\n" - " case (x)\n" - " kZ: gg h ();\n" // align - " //c1\n" - " kXYY: j kk ();\n" - " endcase\n" - "endmodule\n"}, - {// case-generate: align would add too many space, so flush-left - "module mc ; case (x)kZ : gg h(); kXYYYY :j kk();" - "endcase endmodule\n", - "module mc;\n" - " case (x)\n" - " kZ: gg h ();\n" // flush-left - " kXYYYY: j kk ();\n" - " endcase\n" - "endmodule\n"}, - {// case-generate: inject spaces to induce alignment - "module mc ; case (x)kZ : gg h(); kXYYYY : j kk();" - "endcase endmodule\n", - "module mc;\n" - " case (x)\n" - " kZ: gg h ();\n" // align - " kXYYYY: j kk ();\n" - " endcase\n" - "endmodule\n"}, - {// randcase: align (small difference from flush-left) - "task trc ;randcase 10: x = 1; 1: x = 3; endcase endtask", - "task trc;\n" - " randcase\n" - " 10: x = 1;\n" - " 1: x = 3;\n" // aligned - " endcase\n" - "endtask\n"}, - {// randcase: inferred flush-left - "task trc ;randcase 10000: x = 1; 1: x = 3; endcase endtask", - "task trc;\n" - " randcase\n" - " 10000: x = 1;\n" - " 1: x = 3;\n" - " endcase\n" - "endtask\n"}, - {// randcase: induce alignment - "task trc ;randcase 10000: x = 1 ; 1: x = 3; endcase endtask", - "task trc;\n" - " randcase\n" - " 10000: x = 1;\n" - " 1: x = 3;\n" // aligned - " endcase\n" - "endtask\n"}, - - // distributions - {"class foo;\n" - "constraint c { " - "timer_enable dist {\n" - "8'hfe := 9 , \n" - "12'hfff := 1 }; " - "} endclass\n", - "class foo;\n" - " constraint c {\n" - " timer_enable dist {\n" - " 8'hfe := 9,\n" // only two spaces needed to align - " 12'hfff := 1\n" // so align - " };\n" - " }\n" - "endclass\n"}, - {"class foo;\n" - "constraint c { " - "timer_enable dist {\n" - "[ 8'h0 : 8'hfe ] :/ 9 , \n" - "8'hff :/ 1 }; " // takes many spaces to align this, so... - "} endclass\n", - "class foo;\n" - " constraint c {\n" - " timer_enable dist {\n" - " [8'h0 : 8'hfe] :/ 9,\n" - " 8'hff :/ 1\n" // flush-left - " };\n" - " }\n" - "endclass\n"}, - {"class foo;\n" - "constraint c { " - "timer_enable dist {\n" - "[ 8'h0 : 8'hfe ] :/ 9 , \n" - "8'hff :/ 1 }; " // inject excess spaces to trigger alignment - "} endclass\n", - "class foo;\n" - " constraint c {\n" - " timer_enable dist {\n" - " [8'h0 : 8'hfe] :/ 9,\n" - " 8'hff :/ 1\n" // aligned - " };\n" - " }\n" - "endclass\n"}, - {"class foo;\n" - "constraint c { " - "timer_enable dist {\n" - "//comment1\n" - "[ 8'h0 : 8'hfe ] :/ 9 , \n" - "//comment2\n" - "8'hff :/ 1 \n" - "//comment3\n" - "}; " // inject excess spaces to trigger alignment - "} endclass\n", - "class foo;\n" - " constraint c {\n" - " timer_enable dist {\n" - " //comment1\n" - " [8'h0 : 8'hfe] :/ 9,\n" - " //comment2\n" // align across comment - " 8'hff :/ 1\n" // aligned - " //comment3\n" - " };\n" - " }\n" - "endclass\n"}, - {"module foo ();\n" - " always @(posedge bar) begin\n" - " if (1==1) begin\n" - " ham();\n" - " end else if (2==2) begin\n" - " jam();\n" - " end else begin\n" - " spam();\n" - " end\n" - " end\n" - "endmodule\n", - "module foo ();\n" - " always @(posedge bar) begin\n" - " if (1 == 1) begin\n" - " ham();\n" - " end else if (2 == 2) begin\n" - " jam();\n" - " end else begin\n" - " spam();\n" - " end\n" - " end\n" - "endmodule\n"}, - }; - // Use a fixed style. - FormatStyle style; - style.column_limit = 40; - style.indentation_spaces = 2; - style.wrap_spaces = 4; - // Override some settings to test auto-inferred alignment. - style.ApplyToAllAlignmentPolicies(AlignmentPolicy::kInferUserIntent); - - for (const auto &test_case : kTestCases) { - VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; - std::ostringstream stream; - const auto status = - FormatVerilog(test_case.input, "<filename>", style, stream); - // Require these test cases to be valid. - EXPECT_OK(status) << status.message(); - EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; - } -} // NOLINT(readability/fn_size) - -static constexpr FormatterTestCase kFormatterWideTestCases[] = { - // specify blocks - {"module specify_tests ;\n" - "specify\n" // empty list - "endspecify\n" - "endmodule", - "module specify_tests;\n" - " specify\n" - " endspecify\n" - "endmodule\n"}, - {"module specify_tests ;\n" - "specify\n" - "$recrem (posedge R, posedge C,\n" - "t1, t2);\n" - "endspecify\n" - "endmodule", - "module specify_tests;\n" - " specify\n" - " $recrem(posedge R, posedge C, t1, t2);\n" - " endspecify\n" - "endmodule\n"}, - {"module specify_tests ;\n" - "specify\n" - "// TODO: add this\n" - "endspecify \n" - "endmodule", - "module specify_tests;\n" - " specify\n" - " // TODO: add this\n" - " endspecify\n" - "endmodule\n"}, - {"module specify_tests ;\n" - "specify \n" - " //c1\n" - "$setup ( posedge A, posedge B,\n" - "t1);//c2\n" - " //c3\n" - "$hold ( posedge B , posedge A,t2); //c4\n" - "\t//c5\n" - "endspecify\n" - "endmodule", - "module specify_tests;\n" - " specify\n" - " //c1\n" - " $setup(posedge A, posedge B, t1); //c2\n" - " //c3\n" - " $hold(posedge B, posedge A, t2); //c4\n" - " //c5\n" - " endspecify\n" - "endmodule\n"}, - {"module specify_tests ;\n" - "specify \n" - "$setup ( posedge A, posedge B,\n" - "t1);\n" - "$hold ( posedge B , posedge A,t2);\n" - "endspecify\n" - "endmodule", - "module specify_tests;\n" - " specify\n" - " $setup(posedge A, posedge B, t1);\n" - " $hold(posedge B, posedge A, t2);\n" - " endspecify\n" - "endmodule\n"}, - {"module specify_tests ;\n" - "specify \n" - " `ifdef CCC\n" - "$setup ( posedge A, posedge B,\n" - "t1);\n" - " `else\n" - "$hold ( posedge B , posedge A,t2); \n" - "\t`endif\n" - "endspecify\n" - "endmodule", - "module specify_tests;\n" - " specify\n" - "`ifdef CCC\n" - " $setup(posedge A, posedge B, t1);\n" - "`else\n" - " $hold(posedge B, posedge A, t2);\n" - "`endif\n" - " endspecify\n" - "endmodule\n"}, -}; - -// These tests just need a larger column limit to fit on one line. -TEST(FormatterEndToEndTest, VerilogFormatWideTest) { - // Use a fixed style. - FormatStyle style; - style.column_limit = 60; - style.indentation_spaces = 2; - style.wrap_spaces = 4; - for (const auto &test_case : kFormatterWideTestCases) { - VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; - std::ostringstream stream; - const auto status = - FormatVerilog(test_case.input, "<filename>", style, stream); - // Require these test cases to be valid. - EXPECT_OK(status) << status.message(); - EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; - } -} - -TEST(FormatterEndToEndTest, DisableModulePortDeclarations) { - static constexpr FormatterTestCase kTestCases[] = { - {"", ""}, - {"\n", "\n"}, - {"\n\n", "\n\n"}, - {"module m ;\t\n" - " endmodule\n", - "module m;\n" - "endmodule\n"}, - {"module m( ) ;\n" - " endmodule\n", - "module m ();\n" // empty ports formatted compactly - "endmodule\n"}, - {// for a single port, the alignment handler doesn't even consider it a - // group so it falls back to standard flush-left behavior. - "module m ( input clk )\t;\n" - " endmodule\n", - "module m (\n" - " input clk\n" - ");\n" - "endmodule\n"}, - {// example with two ports - "module m (\n" - "input clk,\n" - "output bar\n" - ")\t;\n" - " endmodule\n", - "module m (\n" - " input clk,\n" // indented, but internal pre-existing spacing - // preserved - " output bar\n" - ");\n" - "endmodule\n"}, - }; - FormatStyle style; - style.column_limit = 40; - style.indentation_spaces = 2; - style.wrap_spaces = 4; - style.port_declarations_alignment = verible::AlignmentPolicy::kPreserve; - for (const auto &test_case : kTestCases) { - VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; - std::ostringstream stream; - const auto status = - FormatVerilog(test_case.input, "<filename>", style, stream); - // Require these test cases to be valid. - EXPECT_OK(status) << status.message(); - EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; - } -} - -TEST(FormatterEndToEndTest, DisableModuleInstantiations) { - static constexpr FormatterTestCase kTestCases[] = { - {"", ""}, - {"\n", "\n"}, - {"\n\n", "\n\n"}, - {"module m ;\t\n" - " endmodule\n", - "module m;\n" - "endmodule\n"}, - {"module m ;\t\n" - "foo bar();" - " endmodule\n", - "module m;\n" - " foo bar ();\n" // indentation still takes effect - "endmodule\n"}, - {"module m ;\t\n" - "logic xyz;" - "wire\tabc;" - " endmodule\n", - "module m;\n" - " logic xyz;\n" // indentation still takes effect - " wire abc;\n" // aligned too - "endmodule\n"}, - {" function f ;\t\n" - " endfunction\n", - "function f;\n" - "endfunction\n"}, - {" function f ;\t" - "foo bar,baz; " - " endfunction\n", - "function f;\n" - " foo bar, baz;\n" - "endfunction\n"}, - {" task t ;\t" - "foo bar,baz; " - " endtask\n", - "task t;\n" - " foo bar, baz;\n" - "endtask\n"}, - {"module m ;\t\n" - "foo bar( .baz(baz) );" - " endmodule\n", - "module m;\n" - " foo bar (.baz(baz));\n" // indentation still takes effect - "endmodule\n"}, - {"module m ;\t\n" - "foo bar(\n" - " .baz (baz ),\n" // example of user-manual alignment - " .blaaa(blaaa)\n" - ");" - " endmodule\n", - "module m;\n" - " foo bar (\n" // indentation still takes effect - " .baz (baz ),\n" // named port connections preserved - " .blaaa(blaaa)\n" // named port connections preserved - " );\n" // this indentation is fixed - "endmodule\n"}, - {"module m ;\t\n" - "foo #( .baz(baz) ) bar();" // named parameters - " endmodule\n", - "module m;\n" - " foo #(.baz(baz)) bar ();\n" // indentation still takes effect - "endmodule\n"}, - {"module m ;\t\n" - "foo #(\n" - " .baz (baz ),\n" // example of user-manual alignment - " .blaaa(blaaa)\n" - ") bar( );" - " endmodule\n", - "module m;\n" - " foo #(\n" // indentation still takes effect - " .baz (baz ),\n" // named parameter arguments preserved - " .blaaa(blaaa)\n" // named parameter arguments preserved - " ) bar ();\n" // this indentation is fixed - "endmodule\n"}, - }; - FormatStyle style; - style.column_limit = 40; - style.indentation_spaces = 2; - style.wrap_spaces = 4; - // Testing preservation of spaces - style.named_parameter_alignment = AlignmentPolicy::kPreserve; - style.named_port_alignment = AlignmentPolicy::kPreserve; - for (const auto &test_case : kTestCases) { - VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; - std::ostringstream stream; - const auto status = - FormatVerilog(test_case.input, "<filename>", style, stream); - // Require these test cases to be valid. - EXPECT_OK(status) << status.message(); - EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; - } -} - -TEST(FormatterEndToEndTest, DisableTryWrapLongLines) { - static constexpr FormatterTestCase kTestCases[] = { - {"", ""}, - {"\n", "\n"}, - {"\n\n", "\n\n"}, - {"module m ;\t\n" - " endmodule\n", - "module m;\n" - "endmodule\n"}, - {"module m( ) ;\n" - " endmodule\n", - "module m ();\n" - "endmodule\n"}, - {"module m( ) ;\n" - "initial assign a = b;\n" - " endmodule\n", - "module m ();\n" - " initial assign a = b;\n" - "endmodule\n"}, - {"module m( ) ;\n" - "initial assign a = {never +gonna +give +you +up,\n" - "never + gonna +Let +you +down};\n" - " endmodule\n", - "module m ();\n" - " initial\n" - " assign a = {\n" - " never + gonna + give + you + up,\n" - " never + gonna + Let + you + down\n" - " };\n" - "endmodule\n"}, - {"module m( ) ;\n" - "initial assign a = {never +gonna +give +you +up+\n" // over 40 columns, - // give up - "never + gonna +Let +you +down};\n" - " endmodule\n", - "module m ();\n" - " initial\n" - " assign a = {\n" - " never +gonna +give +you +up+\n" // indented properly, but - "never + gonna +Let +you +down\n" // preserved original - " };\n" - "endmodule\n"}, - {// The if-header is a single leaf partition, and does not fit, - // so its original spacing should be preserved. - // We deliberately insert weird spacing to show that it is preserved. - "function f;\n" - "if ((xxx.aaaa >= bbbbbbbbbbbbbbb) &&\n" - " ((ccc.ddd + eee.ffffff * g) <=\n" - " (hhhhhhhhhhhhhhh+iiiiiiiiiiiiiiiiiiii))) begin\n" - "end\n" - "endfunction\n", - "function f;\n" - " if ((xxx.aaaa >= bbbbbbbbbbbbbbb) &&\n" // indentation fixed - " ((ccc.ddd + eee.ffffff * g) <=\n" - " (hhhhhhhhhhhhhhh+iiiiiiiiiiiiiiiiiiii))) begin\n" - " end\n" // indentation fixed - "endfunction\n"}, - - // Make sure indentation still works with wrapping disabled, - // and leaf partitions fit on one line. - {"function void f();\n" - "for (int i = N; i > 0; i--) begin\n" - "end\n" - "endfunction\n", - "function void f();\n" - " for (int i = N; i > 0; i--) begin\n" - " end\n" - "endfunction\n"}, - {"function void f();" - "if(i > 0 ) begin end " - "endfunction", - "function void f();\n" - " if (i > 0) begin\n" - " end\n" - "endfunction\n"}, - {"function void f();" // newlines absent from input - "for (int i=N; i>0; i--) begin end " - "endfunction", - "function void f();\n" - " for (int i = N; i > 0; i--) begin\n" // spacing corrected - " end\n" - "endfunction\n"}, - {"module m( );\n" - " always_ff @ ( posedge ( clk ) ) begin\n" - "out <= rst_clk ? 0 : in ;\n" - "end\n" - "endmodule : simple\n", - "module m ();\n" - " always_ff @(posedge (clk)) begin\n" - " out <= rst_clk ? 0 : in;\n" - " end\n" - "endmodule : simple\n"}, - }; - FormatStyle style; - style.column_limit = 40; - style.indentation_spaces = 2; - style.wrap_spaces = 4; - style.try_wrap_long_lines = false; - for (const auto &test_case : kTestCases) { - VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; - std::ostringstream stream; - const auto status = - FormatVerilog(test_case.input, "<filename>", style, stream); - // Require these test cases to be valid. - EXPECT_OK(status) << status.message(); - EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; - } -} - -TEST(FormatterEndToEndTest, ModulePortDeclarationsIndentNotWrap) { - static constexpr FormatterTestCase kTestCases[] = { - {"", ""}, - {"\n", "\n"}, - {"\n\n", "\n\n"}, - {"module m ;\t\n" - " endmodule\n", - "module m;\n" - "endmodule\n"}, - {"module m( ) ;\n" - " endmodule\n", - "module m ();\n" // empty ports formatted compactly - "endmodule\n"}, - {// single port example - "module m ( input clk )\t;\n" - " endmodule\n", - "module m (\n" - " input clk\n" // 2 spaces - ");\n" - "endmodule\n"}, - {// example with two ports - "module m (\n" - "input clk,\n" - "output bar\n" - ")\t;\n" - " endmodule\n", - "module m (\n" - " input clk,\n" // indented 2 spaces, and aligned - " output bar\n" - ");\n" - "endmodule\n"}, - {// interface example - "interface handshake (\n" - "wire req,\n" - "wire ack\n" - ")\t;\n" - " endinterface\n", - "interface handshake (\n" - " wire req,\n" // indented 2 spaces - " wire ack\n" - ");\n" - "endinterface\n"}, - }; - FormatStyle style; - style.column_limit = 40; - style.indentation_spaces = 2; - style.wrap_spaces = 4; - // Indent 2 spaces instead of wrapping 4 spaces. - style.port_declarations_indentation = IndentationStyle::kIndent; - for (const auto &test_case : kTestCases) { - VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; - std::ostringstream stream; - const auto status = - FormatVerilog(test_case.input, "<filename>", style, stream); - // Require these test cases to be valid. - EXPECT_OK(status) << status.message(); - EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; - } -} - -TEST(FormatterEndToEndTest, NamedPortConnectionsIndentNotWrap) { - static constexpr FormatterTestCase kTestCases[] = { - {"", ""}, - {"\n", "\n"}, - {"\n\n", "\n\n"}, - {"module m ;\t\n" - " endmodule\n", - "module m;\n" - "endmodule\n"}, - {"module m( ) ;\n" - " endmodule\n", - "module m ();\n" // empty ports formatted compactly - "endmodule\n"}, - {// single port example - "module m ;\n" - "foo bar( .clk( clk ) )\t;\n" - " endmodule\n", - "module m;\n" - " foo bar (.clk(clk));\n" - "endmodule\n"}, - {// two port example - "module m ;\n" - "foo bar( .clk2( clk ),.data (data) )\t;\n" - " endmodule\n", - "module m;\n" - " foo bar (\n" - " .clk2(clk),\n" // indent only +2 spaces - " .data(data)\n" - " );\n" - "endmodule\n"}, - }; - FormatStyle style; - style.column_limit = 40; - style.indentation_spaces = 2; - style.wrap_spaces = 4; - // Indent 2 spaces instead of wrapping 4 spaces. - style.named_port_indentation = IndentationStyle::kIndent; - for (const auto &test_case : kTestCases) { - VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; - std::ostringstream stream; - const auto status = - FormatVerilog(test_case.input, "<filename>", style, stream); - // Require these test cases to be valid. - EXPECT_OK(status) << status.message(); - EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; - } -} - -TEST(FormatterEndToEndTest, WrapEndElseStatements) { - static constexpr FormatterTestCase kTestCases[] = { - {"module foo ();\n" - " always @(posedge bar) begin\n" - " if (1==1) begin\n" - " ham();\n" - " end else if (2==2) begin\n" - " jam();\n" - " end else begin\n" - " spam();\n" - " end\n" - " end\n" - "endmodule\n", - "module foo ();\n" - " always @(posedge bar) begin\n" - " if (1 == 1) begin\n" - " ham();\n" - " end\n" - " else if (2 == 2) begin\n" - " jam();\n" - " end\n" - " else begin\n" - " spam();\n" - " end\n" - " end\n" - "endmodule\n"}, - }; - FormatStyle style; - style.column_limit = 40; - style.indentation_spaces = 2; - style.wrap_spaces = 4; - style.wrap_end_else_clauses = true; - for (const auto &test_case : kTestCases) { - VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; - std::ostringstream stream; - const auto status = - FormatVerilog(test_case.input, "<filename>", style, stream); - // Require these test cases to be valid. - EXPECT_OK(status) << status.message(); - EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; - } -} - -TEST(FormatterEndToEndTest, FormalParametersIndentNotWrap) { - static constexpr FormatterTestCase kTestCases[] = { - {"", ""}, - {"\n", "\n"}, - {"\n\n", "\n\n"}, - {"module m ;\t\n" - " endmodule\n", - "module m;\n" - "endmodule\n"}, - {"module m #( ) ;\n" // empty parameters - " endmodule\n", - "module m #();\n" - "endmodule\n"}, - {// single parameter example - "module m #( int W = 2)\t;\n" - " endmodule\n", - "module m #(\n" - " int W = 2\n" // indented 2 spaces - ");\n" - "endmodule\n"}, - {// module with two parameters - "module m #(\n" - "int W = 2,\n" - "int L = 4\n" - ")\t;\n" - " endmodule\n", - "module m #(\n" - " int W = 2,\n" // indented 2 spaces - " int L = 4\n" - ");\n" - "endmodule\n"}, - {// interface with two parameters - "interface m #(\n" - "int W = 2,\n" - "int L = 4\n" - ")\t;\n" - " endinterface\n", - "interface m #(\n" - " int W = 2,\n" // indented 2 spaces - " int L = 4\n" - ");\n" - "endinterface\n"}, - {// class with two parameters - "class c #(\n" - "int W = 2,\n" - "int L = 4\n" - ")\t;\n" - " endclass\n", - "class c #(\n" - " int W = 2,\n" // indented 2 spaces - " int L = 4\n" - ");\n" - "endclass\n"}, - }; - FormatStyle style; - style.column_limit = 40; - style.indentation_spaces = 2; - style.wrap_spaces = 4; - // Indent 2 spaces instead of wrapping 4 spaces. - style.formal_parameters_indentation = IndentationStyle::kIndent; - for (const auto &test_case : kTestCases) { - VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; - std::ostringstream stream; - const auto status = - FormatVerilog(test_case.input, "<filename>", style, stream); - // Require these test cases to be valid. - EXPECT_OK(status) << status.message(); - EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; - } -} - -TEST(FormatterEndToEndTest, NamedParametersIndentNotWrap) { - static constexpr FormatterTestCase kTestCases[] = { - {"", ""}, - {"\n", "\n"}, - {"\n\n", "\n\n"}, - {"module m ;\t\n" - " endmodule\n", - "module m;\n" - "endmodule\n"}, - {"module m #( ) ;\n" // empty parameters - " endmodule\n", - "module m #();\n" - "endmodule\n"}, - {"module m ;\t\n" - " foo #()bar();\n" - " endmodule\n", - "module m;\n" - " foo #() bar ();\n" - "endmodule\n"}, - {// one named parameter - "module m ;\n" - "foo #(.W(1)) bar();\n" - " endmodule\n", - "module m;\n" - " foo #(.W(1)) bar ();\n" - "endmodule\n"}, - {// two named parameters - "module m ;\n" - "foo #(.W(1), .L(2)) bar();\n" - " endmodule\n", - "module m;\n" - " foo #(\n" - " .W(1),\n" // indent +2 spaces only - " .L(2)\n" - " ) bar ();\n" - "endmodule\n"}, - {// class data member with two parameters - "class c ;\n" - " foo_pkg::bar_t#(\n" - ".W(2),.L(4)" - ") baz;\n" - " endclass\n", - "class c;\n" - " foo_pkg::bar_t #(\n" - " .W(2),\n" // indent +2 spaces only - " .L(4)\n" - " ) baz;\n" - "endclass\n"}, - {// typedef with two parameters - "typedef \n" - " foo_pkg::bar_t #(" - ".W(2),.L(4)" - ") baz;\n", - "typedef foo_pkg::bar_t#(\n" - " .W(2),\n" // indent +2 spaces only - " .L(4)\n" - ") baz;\n"}, - }; - FormatStyle style; - style.column_limit = 40; - style.indentation_spaces = 2; - style.wrap_spaces = 4; - // Indent 2 spaces instead of wrapping 4 spaces. - style.named_parameter_indentation = IndentationStyle::kIndent; - for (const auto &test_case : kTestCases) { - VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; - std::ostringstream stream; - const auto status = - FormatVerilog(test_case.input, "<filename>", style, stream); - // Require these test cases to be valid. - EXPECT_OK(status) << status.message(); - EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; - } -} - -struct SelectLinesTestCase { - std::string_view input; - LineNumberSet lines; // explicit set of lines to enable formatting - std::string_view expected; -}; - -// Tests that formatter honors selected line numbers. -TEST(FormatterEndToEndTest, SelectLines) { - const SelectLinesTestCase kTestCases[] = { - {"", {}, ""}, - {"", {{1, 2}}, ""}, - {// expect all three lines for format - " parameter int foo_line1 = 0 ;\n" - " parameter int foo_line2 = 0 ;\n" - " parameter int foo_line3 = 0 ;\n", - {}, - "parameter int foo_line1 = 0;\n" - "parameter int foo_line2 = 0;\n" - "parameter int foo_line3 = 0;\n"}, - {// expect only one line to format - " parameter int foo_line1 = 0 ;\n" - " parameter int foo_line2 = 0 ;\n" - " parameter int foo_line3 = 0 ;\n", - {{1, 2}}, - "parameter int foo_line1 = 0;\n" - " parameter int foo_line2 = 0 ;\n" - " parameter int foo_line3 = 0 ;\n"}, - {// expect only one line to format - " parameter int foo_line1 = 0 ;\n" - " parameter int foo_line2 = 0 ;\n" - " parameter int foo_line3 = 0 ;\n", - {{2, 3}}, - " parameter int foo_line1 = 0 ;\n" - "parameter int foo_line2 = 0;\n" - " parameter int foo_line3 = 0 ;\n"}, - {// expect only one line to format - " parameter int foo_line1 = 0 ;\n" - " parameter int foo_line2 = 0 ;\n" - " parameter int foo_line3 = 0 ;\n", - {{3, 4}}, - " parameter int foo_line1 = 0 ;\n" - " parameter int foo_line2 = 0 ;\n" - "parameter int foo_line3 = 0;\n"}, - {// expect to format two lines - " parameter int foo_line1 = 0 ;\n" - " parameter int foo_line2 = 0 ;\n" - " parameter int foo_line3 = 0 ;\n", - {{1, 3}}, - "parameter int foo_line1 = 0;\n" - "parameter int foo_line2 = 0;\n" - " parameter int foo_line3 = 0 ;\n"}, - {// expect to format two lines - " parameter int foo_line1 = 0 ;\n" - " parameter int foo_line2 = 0 ;\n" - " parameter int foo_line3 = 0 ;\n", - {{2, 4}}, - " parameter int foo_line1 = 0 ;\n" - "parameter int foo_line2 = 0;\n" - "parameter int foo_line3 = 0;\n"}, - {// expect to format two lines - " parameter int foo_line1 = 0 ;\n" - " parameter int foo_line2 = 0 ;\n" - " parameter int foo_line3 = 0 ;\n", - {{1, 2}, {3, 4}}, - "parameter int foo_line1 = 0;\n" - " parameter int foo_line2 = 0 ;\n" - "parameter int foo_line3 = 0;\n"}, - {// expect to format all lines - " parameter int foo_line1 = 0 ;\n" - " parameter int foo_line2 = 0 ;\n" - " parameter int foo_line3 = 0 ;\n", - {{1, 4}}, - "parameter int foo_line1 = 0;\n" - "parameter int foo_line2 = 0;\n" - "parameter int foo_line3 = 0;\n"}, - {// expect to format no lines (line numbers out of bounds) - " parameter int foo_line1 = 0 ;\n" - " parameter int foo_line2 = 0 ;\n" - " parameter int foo_line3 = 0 ;\n", - {{4, 6}}, - " parameter int foo_line1 = 0 ;\n" - " parameter int foo_line2 = 0 ;\n" - " parameter int foo_line3 = 0 ;\n"}, - {// expect to format all lines - "// verilog_format: on\n" - " parameter int foo_line2 = 0 ;\n" - " parameter int foo_line3 = 0 ;\n" - " parameter int foo_line4 = 0 ;\n", - {}, - "// verilog_format: on\n" - "parameter int foo_line2 = 0;\n" - "parameter int foo_line3 = 0;\n" - "parameter int foo_line4 = 0;\n"}, - {// expect to format no lines - "// verilog_format: off\n" - " parameter int foo_line2 = 0 ;\n" - " parameter int foo_line3 = 0 ;\n" - " parameter int foo_line4 = 0 ;\n", - {}, - "// verilog_format: off\n" - " parameter int foo_line2 = 0 ;\n" - " parameter int foo_line3 = 0 ;\n" - " parameter int foo_line4 = 0 ;\n"}, - {// expect to format some lines - "// verilog_format: on\n" - " parameter int foo_line2 = 0 ;\n" - " parameter int foo_line3 = 0 ;\n" - " parameter int foo_line4 = 0 ;\n", - {{3, 5}}, - "// verilog_format: on\n" - " parameter int foo_line2 = 0 ;\n" - "parameter int foo_line3 = 0;\n" // disable lines 3,4 - "parameter int foo_line4 = 0;\n"}, - {// enable all lines, but respect format-off - " parameter int foo_line1 = 0 ;\n" - " parameter int foo_line2 = 0 ;\n" - "// verilog_format: off\n" - " parameter int foo_line4 = 0 ;\n", - {{1, 5}}, - "parameter int foo_line1 = 0;\n" - "parameter int foo_line2 = 0;\n" - "// verilog_format: off\n" - " parameter int foo_line4 = 0 ;\n"}, - {// enable all lines, but respect format-off - " parameter int foo_line1 = 0 ;\n" - "// verilog_format: off\n" - " parameter int foo_line3 = 0 ;\n" - "// verilog_format: on\n" - " parameter int foo_line5 = 0 ;\n", - {{1, 6}}, - "parameter int foo_line1 = 0;\n" - "// verilog_format: off\n" - " parameter int foo_line3 = 0 ;\n" - "// verilog_format: on\n" - "parameter int foo_line5 = 0;\n"}, - {// enable all lines, but respect format-off - "// verilog_format: off\n" - " parameter int foo_line2 = 0 ;\n" - " parameter int foo_line3 = 0 ;\n" - "// verilog_format: on\n" - " parameter int foo_line5 = 0 ;\n", - {{1, 6}}, - "// verilog_format: off\n" - " parameter int foo_line2 = 0 ;\n" - " parameter int foo_line3 = 0 ;\n" - "// verilog_format: on\n" - "parameter int foo_line5 = 0;\n"}, - {"module m;\n" - " if (foo) begin:l1\n" - " if (foo) begin:l2\n" - " always_comb\n" // normally this line and next would fit together - " d<=#1ps x_lat\t;\n" // only format this line, 5 - " end : l2\n" - " end : l1\n" - "endmodule\n", - {{5, 6}}, - "module m;\n" - " if (foo) begin:l1\n" - " if (foo) begin:l2\n" - " always_comb\n" // incremental mode prevents joining next line - " d <= #1ps x_lat;\n" // only this line changed - " end : l2\n" - " end : l1\n" - "endmodule\n"}, - - // Next three test cases: one whole-file, two incremental - {"module m(\n" - " input wire f,\n" - " input foo::bar ggg\n" - ");\n" - "endmodule:m\n", - {}, // format all lines - "module m (\n" - " input wire f,\n" - " input foo::bar ggg\n" - ");\n" - "endmodule : m\n"}, - {"module m(\n" - " input wire f,\n" - " input foo::bar ggg\n" // "new line", formatted incrementally - ");\n" - "endmodule:m\n", - {{3, 4}}, // format incrementally - "module m(\n" - " input wire f,\n" - " input foo::bar ggg\n" // "new line" remains untouched - ");\n" - "endmodule:m\n"}, - {"module m(\n" - " input wire f,\n" // "new line", formatted incrementally - " input foo::bar ggg\n" - ");\n" - "endmodule:m\n", - {{2, 3}}, // format incrementally - "module m(\n" - " input wire f,\n" // "new line" indented, but other spaces kept - " input foo::bar ggg\n" - ");\n" - "endmodule:m\n"}, - }; - // Use a fixed style. - FormatStyle style; - style.column_limit = 40; - style.indentation_spaces = 2; - style.wrap_spaces = 4; - for (const auto &test_case : kTestCases) { - VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; - std::ostringstream stream; - const auto status = FormatVerilog(test_case.input, "<filename>", style, - stream, test_case.lines); - EXPECT_OK(status) << status.message() << '\n' - << "Lines: " << test_case.lines; - EXPECT_EQ(stream.str(), test_case.expected) - << "code:\n" - << test_case.input << "\nlines: " << test_case.lines; - } -} - -// These tests verify the mode where horizontal spacing is discarded while -// vertical spacing is preserved. -TEST(FormatterEndToEndTest, PreserveVSpacesOnly) { - static constexpr FormatterTestCase kTestCases[] = { - // {input, expected}, - // No tokens cases: still preserve vertical spacing, but not horizontal - {"", ""}, - {" ", ""}, - {"\n", "\n"}, - {"\n\n", "\n\n"}, - {" \n", "\n"}, - {"\n ", "\n"}, - {" \n ", "\n"}, - {" \n \t\t\n\t ", "\n\n"}, - - // The remaining cases have at least one non-whitespace token. - - // single comment - {"//\n", "//\n"}, - {"// \n", "// \n"}, // trailing spaces inside comment untouched - {"\n//\n", "\n//\n"}, - {"\n\n//\n", "\n\n//\n"}, - {"\n//\n\n", "\n//\n\n"}, - {" //\n", "//\n"}, // spaces before comment discarded - {" \n //\n", "\n//\n"}, - {" \n //\n \n ", "\n//\n\n"}, // trailing spaces discarded - - // multi-comment - {"//\n//\n", "//\n//\n"}, - {"\n//\n\n//\n\n", "\n//\n\n//\n\n"}, - {"\n//\n\n//\n", "\n//\n\n//\n"}, // blank line between comments - - // Module cases with token partition boundary (before 'endmodule'). - {"module foo;endmodule\n", "module foo;\nendmodule\n"}, - {"module foo;\nendmodule\n", "module foo;\nendmodule\n"}, - {"module foo;\n\nendmodule\n", "module foo;\n\nendmodule\n"}, - {"\nmodule foo;endmodule\n", "\nmodule foo;\nendmodule\n"}, - {"\nmodule foo ; endmodule\n", "\nmodule foo;\nendmodule\n"}, - {"\nmodule\nfoo\n;endmodule\n", "\nmodule foo;\nendmodule\n"}, - {"\nmodule foo;endmodule\n\n\n", "\nmodule foo;\nendmodule\n\n\n"}, - {"\n\n\nmodule foo;endmodule\n", "\n\n\nmodule foo;\nendmodule\n"}, - {"\nmodule\nfoo\n;\n\n\nendmodule\n", "\nmodule foo;\n\n\nendmodule\n"}, - - // Module cases with one indented item, various original vertical spacing - {"module foo;wire w;endmodule\n", "module foo;\n wire w;\nendmodule\n"}, - {" module foo ;wire w ;endmodule \n ", - "module foo;\n wire w;\nendmodule\n"}, - {"\nmodule\nfoo\n;\nwire\nw\n;endmodule\n\n", - "\nmodule foo;\n wire w;\nendmodule\n\n"}, - {"\n\nmodule\nfoo\n;\n\n\nwire\nw\n;\n\nendmodule\n\n", - "\n\nmodule foo;\n\n\n wire w;\n\nendmodule\n\n"}, - - // The following cases show that some horizontal whitespace is discarded, - // while vertical spacing is preserved on partition boundaries. - {" module foo\t \t; endmodule \n", - "module foo;\nendmodule\n"}, - {"\t\n module foo\t\t; endmodule \n", - "\nmodule foo;\nendmodule\n"}, - - // Module with comments intermingled. - { - "//1\nmodule foo;//2\nwire w;//3\n//4\nendmodule\n", - "//1\nmodule foo; //2\n wire w; //3\n //4\nendmodule\n" - // TODO(fangism): whether or not //4 should be indented is - // questionable (in similar cases below too). - }, - {// now with extra blank lines - "//1\n\nmodule foo;//2\n\nwire w;//3\n\n//4\n\nendmodule\n\n", - "//1\n\nmodule foo; //2\n\n wire w; //3\n\n //4\n\nendmodule\n\n"}, - - { - // module with comments-only in some empty blocks, properly indented - " // humble module\n" - " module foo (// non-port comment\n" - "// port comment 1\n" - "// port comment 2\n" - ");// header trailing comment\n" - "// item comment 1\n" - "// item comment 2\n" - "endmodule\n", - "// humble module\n" - "module foo ( // non-port comment\n" - " // port comment 1\n" - " // port comment 2\n" - "); // header trailing comment\n" - " // item comment 1\n" - " // item comment 2\n" - "endmodule\n", - }, - - { - // module with comments around non-empty blocks - " // humble module\n" - " module foo (// non-port comment\n" - "// port comment 1\n" - "input logic f \n" - "// port comment 2\n" - ");// header trailing comment\n" - "// item comment 1\n" - "wire w ; \n" - "// item comment 2\n" - "endmodule\n", - "// humble module\n" - "module foo ( // non-port comment\n" - " // port comment 1\n" - " input logic f\n" - " // port comment 2\n" - "); // header trailing comment\n" - " // item comment 1\n" - " wire w;\n" - " // item comment 2\n" - "endmodule\n", - }, - }; - FormatStyle style; - for (const auto &test_case : kTestCases) { - VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; - std::ostringstream stream; - const auto status = - FormatVerilog(test_case.input, "<filename>", style, stream); - EXPECT_OK(status) << status.message(); - EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; - } -} - -static constexpr FormatterTestCase kFormatterTestCasesElseStatements[] = { - {"module m;" - "task static t; if (r == t) a.b(c); else d.e(f); endtask;" - "endmodule", - "module m;\n" - " task static t;\n" - " if (r == t) a.b(c);\n" - " else d.e(f);\n" - " endtask\n" - " ;\n" // possibly unintended stray ';' - "endmodule\n"}, - {"module m;" - "task static t; if (r == t) begin a.b(c); end else begin d.e(f); end " - "endtask;" - "endmodule", - "module m;\n" - " task static t;\n" - " if (r == t) begin\n" - " a.b(c);\n" - " end else begin\n" - " d.e(f);\n" - " end\n" - " endtask\n" - " ;\n" // stray ';' - "endmodule\n"}, - {"module m;initial begin if(a==b)" - "c.d(e);else\n" - "f.g(h);end endmodule", - "module m;\n" - " initial begin\n" - " if (a == b) c.d(e);\n" - " else f.g(h);\n" - " end\n" - "endmodule\n"}, - {" module m; always_comb begin \n" - " if ( a ) b = 16'hdead ; \n" - " else if ( c ) d= 16 'hbeef ; \n" - " else if (e) f=16'hca_fe ; \n" - "end \n endmodule\n", - "module m;\n" - " always_comb begin\n" - " if (a) b = 16'hdead;\n" - " else if (c) d = 16'hbeef;\n" - " else if (e) f = 16'hca_fe;\n" - " end\n" - "endmodule\n"}, - {"module foo();\n" - "always_comb begin\n" - "value = function_name(.long_parameter(8'hA), .parameter_three(foobar));\n" - "end\n" - "endmodule : foo\n", - "module foo ();\n" - " always_comb begin\n" - " value = function_name(\n" - " .long_parameter(8'hA),\n" - " .parameter_three(foobar)\n" - " );\n" - " end\n" - "endmodule : foo\n"}, - {"module foo();\n" - "always_comb begin\n" - "value = function_name(.a(1), .b(2));\n" - "end\n" - "endmodule : foo\n", - "module foo ();\n" - " always_comb begin\n" - " value = function_name(.a(1), .b(2));\n" - " end\n" - "endmodule : foo\n"}, - {"module foo ();\n" - "always_comb begin\n" - "value = function_name(8'hA, foobar, signal_1234); end\n" - "always_comb begin\n" - "value = function_name(8'hA, foobar); end\n" - "endmodule : foo\n", - "module foo ();\n" - " always_comb begin\n" - " value = function_name(8'hA, foobar,\n" - " signal_1234);\n" - " end\n" - " always_comb begin\n" - " value = function_name(8'hA, foobar);\n" - " end\n" - "endmodule : foo\n"}, - {"module foo ();\n" - "always_comb begin\n" - "value = function_name(8'hA, foobar, signal_1234);\n" - "value = function_name(8'hA, foobar, signal_1234); end\n" - "endmodule : foo\n", - "module foo ();\n" - " always_comb begin\n" - " value = function_name(8'hA, foobar,\n" - " signal_1234);\n" - " value = function_name(8'hA, foobar,\n" - " signal_1234);\n" - " end\n" - "endmodule : foo\n"}, - {"always_comb begin\n" - "value = " - "f(long_parameter_exceeding_col_limit, foo, bar); end\n", - "always_comb begin\n" - " value = f(\n" - " long_parameter_exceeding_col_limit,\n" - " foo,\n" - " bar\n" - " );\n" - "end\n"}, - {"module foo();\n" - "always_comb begin\n" - "value = function_name(8'hA, .parameter_three(foobar));\n" - "end\n" - "endmodule : foo\n", - "module foo ();\n" - " always_comb begin\n" - " value = function_name(\n" - " 8'hA,\n" - " .parameter_three(foobar)\n" - " );\n" - " end\n" - "endmodule : foo\n"}, - {"module foo ();\n" - "always_comb begin\n" - "value = function_name(8'hA, 8'hB, 8'hC, .parameter_four(foo), " - ".par_five(bar));\n" - "end\n" - "endmodule : foo\n", - "module foo ();\n" - " always_comb begin\n" - " value = function_name(\n" - " 8'hA,\n" - " 8'hB,\n" - " 8'hC,\n" - " .parameter_four(foo),\n" - " .par_five(bar)\n" - " );\n" - " end\n" - "endmodule : foo\n"}, - {"class dv_base_mem; function void configure(); \nbegin\n" - "value = func(8'hA, foobar, signal_1234);\n" - "value = new(8'hA, foobar, signal_1234); end\n" - "endfunction : configure endclass\n", - "class dv_base_mem;\n" - " function void configure();\n" - " begin\n" - " value = func(8'hA, foobar,\n" - " signal_1234);\n" - " value = new(8'hA, foobar,\n" - " signal_1234);\n" - " end\n" - " endfunction : configure\n" - "endclass\n"}, - {"module m; initial begin\n" - " if (a||b) c = 1'b1;\n" - "d = 1'b1; if (e)\n" - "begin f = 1'b0; end else begin\n" - " g = h;\n" - " end \n" - " i = 1'b1; " - "end endmodule\n", - "module m;\n" - " initial begin\n" - " if (a || b) c = 1'b1;\n" - " d = 1'b1;\n" - " if (e) begin\n" - " f = 1'b0;\n" - " end else begin\n" - " g = h;\n" - " end\n" - " i = 1'b1;\n" - " end\n" - "endmodule\n"}, - {"module m; initial begin\n" - "if (a&&b&&c) begin\n" - " d = 1'b1;\n" - " if (e) begin\n" - " f = ff;\n" - " end else if ( g ) begin\n" - " h = hh;\n" - "end else if (i) begin\n" - " j = (kk == ll) ? mm :\n" - " gg;\n" - " end else if ( qq ) begin\n" - " if ( xx ||yy ) begin d0 = 1'b0; d1 = " - "1'b1;\n" - " end else if (oo) begin aa = bb; cc = dd;" - " if (zz) zx = xz; else ba = ab;" - " end else \n begin vv = tt ; \n" - " end end " - "end \n else if (uu)\nbegin\n\na=b;if (aa) b = c;\n" - "\nelse if \n (bb) \n\nc =d ;\n\n\n\n\n " - " else e\n\n = h;\n\n" - "end \n else \n begin if(x)y=a;else\nbegin\n" - "\n\n\na=y; if (a) b = c;\n\n\n\nelse\n\n\nd=e;end \n" - "end\n" - "end endmodule\n", - "module m;\n" - " initial begin\n" - " if (a && b && c) begin\n" - " d = 1'b1;\n" - " if (e) begin\n" - " f = ff;\n" - " end else if (g) begin\n" - " h = hh;\n" - " end else if (i) begin\n" - " j = (kk == ll) ? mm : gg;\n" - " end else if (qq) begin\n" - " if (xx || yy) begin\n" - " d0 = 1'b0;\n" - " d1 = 1'b1;\n" - " end else if (oo) begin\n" - " aa = bb;\n" - " cc = dd;\n" - " if (zz) zx = xz;\n" - " else ba = ab;\n" - " end else begin\n" - " vv = tt;\n" - " end\n" - " end\n" - " end else if (uu) begin\n\n" - " a = b;\n" - " if (aa) b = c;\n\n" - " else if (bb) c = d;\n\n\n\n\n" - " else e = h;\n\n" - " end else begin\n" - " if (x) y = a;\n" - " else begin\n\n\n\n" - " a = y;\n" - " if (a) b = c;\n\n\n\n" - " else d = e;\n" - " end\n" - " end\n" - " end\n" - "endmodule\n"}}; - -TEST(FormatterEndToEndTest, FormatElseStatements) { - // Use a fixed style. - FormatStyle style; - style.column_limit = 40; - style.indentation_spaces = 2; - style.wrap_spaces = 4; - for (const auto &test_case : kFormatterTestCasesElseStatements) { - VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; - std::ostringstream stream; - const auto status = - FormatVerilog(test_case.input, "<filename>", style, stream); - EXPECT_OK(status) << status.message(); - EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; - } -} - -TEST(FormatterEndToEndTest, ConstraintExpressions) { - static constexpr FormatterTestCase kTestCases[] = { - {"", ""}, - - // class members - {"class Foo; constraint if_c { if (zzzzzzzzzzzzzzzzzzzzz)" - "{ soft xxxxxxxxxxxxxxxxxxxxxx == yyyyyyyyyyyyyyyyyyy; } } endclass", - "class Foo;\n" - " constraint if_c {\n" - " if (zzzzzzzzzzzzzzzzzzzzz) {\n" - " soft xxxxxxxxxxxxxxxxxxxxxx == yyyyyyyyyyyyyyyyyyy;\n" - " }\n" - " }\n" - "endclass\n"}, - - // constraints with if-constraint expressions - {"constraint xx { if (a) b; }\n", "constraint xx {if (a) b;}\n"}, - - {"constraint xx { if (a) {b;} }\n", - "constraint xx {\n" - " if (a) {\n" - " b;\n" - " }\n" - "}\n"}, - - // multi item constraint - {"constraint yy { a == b;c==d;}", - "constraint yy {\n" - " a == b;\n" - " c == d;\n" - "}\n"}, - - // one-line constraints - {"constraint only_vec_instr_c {soft only_vec_instr == 0;}", - "constraint only_vec_instr_c {soft only_vec_instr == 0;}\n"}, - - {"constraint\nnum_trans_c\n\n\n{\n\n\nnum_trans inside{[800:1000]};}", - "constraint num_trans_c {num_trans inside {[800 : 1000]};}\n"}, - - // if-vs-concatenation expression - {"constraint c_operation{ if(fixed_operation_en){" - "aes_operation == fixed_operation" - ";}}", - "constraint c_operation {\n" - " if (fixed_operation_en) {\n" - " aes_operation == fixed_operation;\n" - " }\n" - "}\n"}, - - {"constraint c_operation{ if(fixed_operation_en){" - "aes_operation == fixed_operation" - "};}", - "constraint c_operation {\n" - " if (fixed_operation_en)\n" - " {aes_operation == fixed_operation};\n" - "}\n"}, - - // concatenation expression - {"constraint c_iv {if (fixed_iv_en) {aes_iv == fixed_iv};}", - "constraint c_iv {\n" - " if (fixed_iv_en)\n" - " {aes_iv == fixed_iv};\n" - "}\n"}, - - // looooong test - {"constraint xx {" - "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)" - "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa==" - "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;" - "ccccccccccccccccccccccc==dddddddddddddddddddddd;}", - "constraint xx {\n" - " if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" - " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == " - "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;\n" - " ccccccccccccccccccccccc == dddddddddddddddddddddd;\n" - "}\n"}, - }; - FormatStyle style; - style.column_limit = - 100; // smaller column_limit forces expansion of constraint blocks - style.indentation_spaces = 2; - style.wrap_spaces = 4; - style.port_declarations_alignment = verible::AlignmentPolicy::kPreserve; - for (const auto &test_case : kTestCases) { - VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; - std::ostringstream stream; - const auto status = - FormatVerilog(test_case.input, "<filename>", style, stream); - // Require these test cases to be valid. - EXPECT_OK(status) << status.message(); - EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; - } -} - -static constexpr FormatterTestCase kFormatterTestCasesEnumDeclarations[] = { - // Inferring user intent: not too many spaces to be added: align. - {"typedef enum { kA=1, kAB=2, kABC=3} x;", - "typedef enum {\n" - " kA = 1,\n" - " kAB = 2,\n" - " kABC = 3\n} x;\n"}, - - // Lots of spaces would've to be be added - keep flush - {"typedef enum { kA=1, kAB=2, kABCDEFGHIJKLMN=3} x;", - "typedef enum {\n" - " kA = 1,\n" - " kAB = 2,\n" - " kABCDEFGHIJKLMN = 3\n} x;\n"}, - - // Source spaces indicate alignment wish. - {"typedef enum { kA =1, kAB=2, kABCDEFGHIJKLMN=3} x;", - "typedef enum {\n" - " kA = 1,\n" - " kAB = 2,\n" - " kABCDEFGHIJKLMN = 3\n} x;\n"}, - - // An empty line groups into several sections, to be aligned independently - {"typedef enum { kA=1, kAB=2, \n\n kABC=3} x;", - "typedef enum {\n" - " kA = 1,\n" - " kAB = 2,\n" - "\n" - " kABC = 3\n} x;\n"}, - - // Lines with comments don't interrupt alignment - {"typedef enum { kA=1,\n" - "// hello world\n" - "kAB=2, kABC=3} x;", - "typedef enum {\n" - " kA = 1,\n" - " // hello world\n" - " kAB = 2,\n" - " kABC = 3\n} x;\n"}, - - // Generally, comment locations are preserved, and full line comments - // indented to enum name level. - {"typedef enum { kA=1,// value kA\n" - "// hello world\n" - "kAB=2,// value kAB\n" - "kABC=3// value kABC\n" - "} x;", - "typedef enum {\n" - " kA = 1, // value kA\n" - " // hello world\n" - " kAB = 2, // value kAB\n" - " kABC = 3 // value kABC" - "\n} x;\n"}, - - {"typedef enum { kA=1,// value kA\n" - "kAB=2,\n" - "kABC=3// value kABC\n" - "} x;", - "typedef enum {\n" - " kA = 1, // value kA\n" - " kAB = 2,\n" - " kABC = 3 // value kABC" - "\n} x;\n"}, - - // Numeric constants are currently flushed left, but maybe todo - // align right in the future ? - {"typedef enum { kA=1, kAB=10, kABC=100} x;", - "typedef enum {\n" - " kA = 1,\n" - " kAB = 10,\n" - " kABC = 100\n} x;\n"}, -}; - -TEST(FormatterEndToEndTest, FormatAlignEnumDeclarations) { - // Use a fixed style. - FormatStyle style; - style.column_limit = 40; - style.indentation_spaces = 2; - style.wrap_spaces = 4; - style.enum_assignment_statement_alignment = AlignmentPolicy::kInferUserIntent; - for (const auto &test_case : kFormatterTestCasesEnumDeclarations) { - VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; - std::ostringstream stream; - const auto status = - FormatVerilog(test_case.input, "<filename>", style, stream); - EXPECT_OK(status) << status.message(); - EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; - } -} - -TEST(FormatterEndToEndTest, DiagnosticShowFullTree) { - // Use a fixed style. - FormatStyle style; - style.column_limit = 40; - style.indentation_spaces = 2; - style.wrap_spaces = 4; - for (const auto &test_case : kFormatterTestCases) { - std::ostringstream stream, debug_stream; - ExecutionControl control; - control.stream = &debug_stream; - control.show_token_partition_tree = true; - const auto status = FormatVerilog(test_case.input, "<filename>", style, - stream, kEnableAllLines, control); - EXPECT_EQ(status.code(), StatusCode::kCancelled); - EXPECT_TRUE( - absl::StartsWith(debug_stream.str(), "Full token partition tree")); - } -} - -TEST(FormatterEndToEndTest, DiagnosticLargestPartitions) { - // Use a fixed style. - FormatStyle style; - style.column_limit = 40; - style.indentation_spaces = 2; - style.wrap_spaces = 4; - for (const auto &test_case : kFormatterTestCases) { - std::ostringstream stream, debug_stream; - ExecutionControl control; - control.stream = &debug_stream; - control.show_largest_token_partitions = 2; - const auto status = FormatVerilog(test_case.input, "<filename>", style, - stream, kEnableAllLines, control); - EXPECT_EQ(status.code(), StatusCode::kCancelled); - EXPECT_TRUE(absl::StartsWith(debug_stream.str(), "Showing the ")) - << "got: " << debug_stream.str(); - } -} - -TEST(FormatterEndToEndTest, DiagnosticEquallyOptimalWrappings) { - // Use a fixed style. - FormatStyle style; - style.column_limit = 40; - style.indentation_spaces = 2; - style.wrap_spaces = 4; - for (const auto &test_case : kFormatterTestCases) { - std::ostringstream stream, debug_stream; - ExecutionControl control; - control.stream = &debug_stream; - control.show_equally_optimal_wrappings = true; - const auto status = FormatVerilog(test_case.input, "<filename>", style, - stream, kEnableAllLines, control); - EXPECT_OK(status) << status.message(); - if (!debug_stream.str().empty()) { - EXPECT_TRUE(absl::StartsWith(debug_stream.str(), "Showing the ")) - << "got: " << debug_stream.str(); - // Cannot guarantee among unit tests that there will be >1 solution. - } - } -} - -// Test that hitting search space limit results in correct error status. -TEST(FormatterEndToEndTest, UnfinishedLineWrapSearching) { - FormatStyle style; - style.column_limit = 40; - style.indentation_spaces = 2; - style.wrap_spaces = 4; - - const std::string_view code("parameter int x = 1+1;\n"); - - std::ostringstream stream, debug_stream; - ExecutionControl control; - control.max_search_states = 2; // Cause search to abort early. - control.stream = &debug_stream; - const auto status = FormatVerilog(code, "<filename>", style, stream, - kEnableAllLines, control); - EXPECT_EQ(status.code(), StatusCode::kResourceExhausted); - EXPECT_TRUE(absl::StartsWith(status.message(), "***")); -} - -static constexpr FormatterTestCase kOnelineFormatBaselineTestCases[] = { - // Reference - following test cases should not be affected by the switch - {// Minimal useful case - "covergroup c @ (posedge clk); coverpoint a; endgroup\n", - "covergroup c @(posedge clk);\n" - " coverpoint a;\n" - "endgroup\n"}, - {// Multiple coverpoints - "covergroup foo @(posedge clk); coverpoint a; coverpoint b; " - "coverpoint c; coverpoint d; endgroup\n", - "covergroup foo @(posedge clk);\n" - " coverpoint a;\n" - " coverpoint b;\n" - " coverpoint c;\n" - " coverpoint d;\n" - "endgroup\n"}, - {// Multiple bins - "covergroup memory @ (posedge ce); address :coverpoint addr {" - "bins low={LOW}; bins high={HIGH};} endgroup\n", - "covergroup memory @(posedge ce);\n" - " address: coverpoint addr {\n" - " bins low = {LOW};\n" - " bins high = {HIGH};\n" - " }\n" - "endgroup\n"}, - {// Multiple bins with multiple elements - "covergroup memory @ (posedge ce); address :coverpoint addr {" - "bins low={0,127}; bins high={128,255};} endgroup\n", - "covergroup memory @(posedge ce);\n" - " address: coverpoint addr {\n" - " bins low = {0, 127};\n" - " bins high = {128, 255};\n" - " }\n" - "endgroup\n"}, -}; - -// Tests that constructs that could be formatted as one-liners are formatted -// correctly. This is the baseline test with default style, test cases should -// not be affected by the setting. -TEST(FormatterEndToEndTest, OnelineFormatBaselineTest) { - // Use a fixed style. - FormatStyle style; - style.column_limit = 40; - style.indentation_spaces = 2; - style.wrap_spaces = 4; - style.expand_coverpoints = false; - for (const auto &test_case : kOnelineFormatBaselineTestCases) { - VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; - std::ostringstream stream; - const auto status = - FormatVerilog(test_case.input, "<filename>", style, stream); - // Require these test cases to be valid. - EXPECT_OK(status) << status.message(); - EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; - } - // Test again with the switch, should not affect formatting - style.expand_coverpoints = true; - for (const auto &test_case : kOnelineFormatBaselineTestCases) { - VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; - std::ostringstream stream; - const auto status = - FormatVerilog(test_case.input, "<filename>", style, stream); - // Require these test cases to be valid. - EXPECT_OK(status) << status.message(); - EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; - } -} - -// Following two test sets are affected by the expand_coverponits switch -// They should contain corresponding test cases -static constexpr FormatterTestCase kOnelineFormatReferenceTestCases[] = { - {// Coverpoint that could fit on one line - "covergroup memory @ (posedge ce); a :coverpoint d {" - "bins l={0};} endgroup\n", - "covergroup memory @(posedge ce);\n" - " a: coverpoint d {bins l = {0};}\n" - "endgroup\n"}, - {// Fit with a reference - "covergroup memory @ (posedge ce); a :coverpoint d {" - "bins l={LOW};} endgroup\n", - "covergroup memory @(posedge ce);\n" - " a: coverpoint d {bins l = {LOW};}\n" - "endgroup\n"}, - {// Fit with multiple elements - "covergroup memory @ (posedge ce); a :coverpoint d {" - "bins l={0,8};} endgroup\n", - "covergroup memory @(posedge ce);\n" - " a: coverpoint d {bins l = {0, 8};}\n" - "endgroup\n"}, -}; - -static constexpr FormatterTestCase kOnelineFormatExpandTestCases[] = { - {// Coverpoint that could fit on one line - "covergroup memory @ (posedge ce); a :coverpoint d {" - "bins l={0};} endgroup\n", - "covergroup memory @(posedge ce);\n" - " a: coverpoint d {\n" - " bins l = {0};\n" - " }\n" - "endgroup\n"}, - {// Fit with a reference - "covergroup memory @ (posedge ce); a :coverpoint d {" - "bins l={LOW};} endgroup\n", - "covergroup memory @(posedge ce);\n" - " a: coverpoint d {\n" - " bins l = {LOW};\n" - " }\n" - "endgroup\n"}, - {// Fit with multiple elements - "covergroup memory @ (posedge ce); a :coverpoint d {" - "bins l={0,8};} endgroup\n", - "covergroup memory @(posedge ce);\n" - " a: coverpoint d {\n" - " bins l = {0, 8};\n" - " }\n" - "endgroup\n"}, -}; - -TEST(FormatterEndToEndTest, OnelineFormatReferenceTest) { - // Use a fixed style. - FormatStyle style; - style.column_limit = 40; - style.indentation_spaces = 2; - style.wrap_spaces = 4; - style.expand_coverpoints = false; - - for (const auto &test_case : kOnelineFormatReferenceTestCases) { - VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; - std::ostringstream stream; - const auto status = - FormatVerilog(test_case.input, "<filename>", style, stream); - // Require these test cases to be valid. - EXPECT_OK(status) << status.message(); - EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; - } -} - -// Tests that constructs that could be formatted as one-liners are expanded -// correctly. This is the baseline test with default style -TEST(FormatterEndToEndTest, OnelineFormatExpandTest) { - // Use a fixed style. - FormatStyle style; - style.column_limit = 40; - style.indentation_spaces = 2; - style.wrap_spaces = 4; - style.expand_coverpoints = true; - - for (const auto &test_case : kOnelineFormatExpandTestCases) { - VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; - std::ostringstream stream; - const auto status = - FormatVerilog(test_case.input, "<filename>", style, stream); - // Require these test cases to be valid. - EXPECT_OK(status) << status.message(); - EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; - } -} - -struct DimensionsAlignmentTestCase { - std::string_view input; - std::string_view expected[4]; -}; - -static constexpr DimensionsAlignmentTestCase - kPortDeclarationDimensionsAlignmentTestCases[] = { - {"import \"DPI-C\" context function void func(\n" - "input bit foo,\n" - "input bit [2] foobar,\n" - "input bit [24:16] bar,\n" - "input bit [2:0][31:0] baz,\n" - "input bit [4][24:0][16:0] foobarbaz[],\n" - "input bit [FOOBAZ][31:24] qux[16],\n" - "input bit [16] quux[8:2][16][32],\n" - "output bit [2:0][2:0][2:0] quuz[8][16:12]\n" - ");\n", - { - "import \"DPI-C\" context function void func(\n" - " input bit foo,\n" - " input bit [ 2] foobar,\n" - " input bit [ 24:16] bar,\n" - " input bit [ 2:0][ 31:0] baz,\n" - " input bit [ 4][ 24:0][16:0] foobarbaz[ ],\n" - " input bit [FOOBAZ][31:24] qux [ 16],\n" - " input bit [ 16] quux [8:2][ 16][32],\n" - " output bit [ 2:0][ 2:0][ 2:0] quuz [ 8][16:12]\n" - ");\n", - "import \"DPI-C\" context function void func(\n" - " input bit foo,\n" - " input bit [ 2] foobar,\n" - " input bit [ 24:16] bar,\n" - " input bit [ 2:0][ 31:0] baz,\n" - " input bit [ 4][ 24:0][16:0] foobarbaz [ ],\n" - " input bit [FOOBAZ][31:24] qux [ 16],\n" - " input bit [ 16] quux [8:2][16][ 32],\n" - " output bit [ 2:0][ 2:0][ 2:0] quuz [ 8][16:12]\n" - ");\n", - "import \"DPI-C\" context function void func(\n" - " input bit foo,\n" - " input bit [ 2] foobar,\n" - " input bit [24:16] bar,\n" - " input bit [ 2:0][ 31:0] baz,\n" - " input bit [ 4][ 24:0][ 16:0] foobarbaz[ ],\n" - " input bit [FOOBAZ][31:24] qux [ 16],\n" - " input bit [ 16] quux [8:2][ 16][32],\n" - " output bit [2:0][ 2:0][ 2:0] quuz [ 8][16:12]\n" - ");\n", - "import \"DPI-C\" context function void func(\n" - " input bit foo,\n" - " input bit [ 2] foobar,\n" - " input bit [24:16] bar,\n" - " input bit [ 2:0][ 31:0] baz,\n" - " input bit [ 4][ 24:0][ 16:0] foobarbaz [ ],\n" - " input bit [FOOBAZ][31:24] qux [ 16],\n" - " input bit [ 16] quux [8:2][16][ 32],\n" - " output bit [2:0][ 2:0][ 2:0] quuz [ 8][16:12]\n" - ");\n", - }}, - {"module m(\n" - "output bit [2:0][2:0][2:0] quuz[8][16:12],\n" - "input bit [16] quux[8:2][16][32],\n" - "input bit [FOOBAZ][31:24] qux[16],\n" - "input bit [4][24:0][16:0] foobaz[],\n" - "input bit [2:0][31:0] baz,\n" - "input bit [24:16] bar,\n" - "input bit [2] foobar,\n" - "input bit foo\n" - "); endmodule:m\n", - { - "module m (\n" - " output bit [ 2:0][ 2:0][ 2:0] quuz [ 8][16:12],\n" - " input bit [ 16] quux [8:2][ 16][32],\n" - " input bit [FOOBAZ][31:24] qux [ 16],\n" - " input bit [ 4][ 24:0][16:0] foobaz[ ],\n" - " input bit [ 2:0][ 31:0] baz,\n" - " input bit [ 24:16] bar,\n" - " input bit [ 2] foobar,\n" - " input bit foo\n" - ");\n" - "endmodule : m\n", - "module m (\n" - " output bit [ 2:0][ 2:0][ 2:0] quuz [ 8][16:12],\n" - " input bit [ 16] quux [8:2][16][ 32],\n" - " input bit [FOOBAZ][31:24] qux [ 16],\n" - " input bit [ 4][ 24:0][16:0] foobaz [ ],\n" - " input bit [ 2:0][ 31:0] baz,\n" - " input bit [ 24:16] bar,\n" - " input bit [ 2] foobar,\n" - " input bit foo\n" - ");\n" - "endmodule : m\n", - "module m (\n" - " output bit [2:0][ 2:0][ 2:0] quuz [ 8][16:12],\n" - " input bit [ 16] quux [8:2][ 16][32],\n" - " input bit [FOOBAZ][31:24] qux [ 16],\n" - " input bit [ 4][ 24:0][ 16:0] foobaz[ ],\n" - " input bit [ 2:0][ 31:0] baz,\n" - " input bit [24:16] bar,\n" - " input bit [ 2] foobar,\n" - " input bit foo\n" - ");\n" - "endmodule : m\n", - "module m (\n" - " output bit [2:0][ 2:0][ 2:0] quuz [ 8][16:12],\n" - " input bit [ 16] quux [8:2][16][ 32],\n" - " input bit [FOOBAZ][31:24] qux [ 16],\n" - " input bit [ 4][ 24:0][ 16:0] foobaz [ ],\n" - " input bit [ 2:0][ 31:0] baz,\n" - " input bit [24:16] bar,\n" - " input bit [ 2] foobar,\n" - " input bit foo\n" - ");\n" - "endmodule : m\n", - }}, -}; - -TEST(FormatterEndToEndTest, PortDeclarationDimensionsAlignmentTest) { - FormatStyle style; - style.column_limit = 64; - style.indentation_spaces = 2; - style.wrap_spaces = 4; - - // All combinations of port_declaration_right_align_{un,}packed_dimensions - static const bool right_align_combinations[][2] = { - {false, false}, {false, true}, {true, false}, {true, true}}; - - for (const auto &test_case : kPortDeclarationDimensionsAlignmentTestCases) { - VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; - size_t expected_index = 0; - for (const auto &right_align : right_align_combinations) { - VLOG(1) << "style variant:\n" - << "port_declarations_right_align_packed_dimensions: " - << right_align[0] << "\n" - << "port_declarations_right_align_unpacked_dimensions: " - << right_align[1] << "\n"; - style.port_declarations_right_align_packed_dimensions = right_align[0]; - style.port_declarations_right_align_unpacked_dimensions = right_align[1]; - - std::ostringstream stream; - - const auto status = - FormatVerilog(test_case.input, "<filename>", style, stream); - // Require these test cases to be valid. - EXPECT_OK(status) << status.message(); - EXPECT_EQ(stream.str(), test_case.expected[expected_index++]) - << "code:\n" - << test_case.input; - } - } -} - -// TODO(fangism): directed tests using style variations - -static constexpr FormatterTestCase kNestedFunctionsTestCases40ColumnsLimit[] = { - {"module foo;" - "`uvm_info(`gfn, $sformatf(\n" - "\"\\n base_vseq: generate %0d pulse in channel %0d\", cfg.num_pulses, " - "i), UVM_DEBUG)\n" - "endmodule", - "module foo;\n" - " `uvm_info(\n" - " `gfn,\n" - " $sformatf(\n" - " \"\\n base_vseq: generate %0d pulse in channel %0d\",\n" - " cfg.num_pulses, i), UVM_DEBUG)\n" - "endmodule\n"}, - {"module foo;`uvm_info(`gfn, $sformatf(" - "\"\\n\\n\\t ----| STARTING AES MAIN SEQUENCE |----\\n %s\"," - "cfg.convert2string()), UVM_LOW)\n" - "endmodule", - "module foo;\n" - " `uvm_info(\n" - " `gfn,\n" - " $sformatf(\n" - " \"\\n\\n\\t ----| STARTING AES MAIN SEQUENCE |----\\n %s\",\n" - " cfg.convert2string()),\n" - " UVM_LOW)\n" // FIXME: Wrapped by SearchLineWraps - "endmodule\n"}, -}; - -TEST(FormatterEndToEndTest, FormatNestedFunctionsTestCases40ColumnsLimit) { - // Use a fixed style. - FormatStyle style; - style.column_limit = 40; - style.indentation_spaces = 2; - style.wrap_spaces = 4; - - for (const auto &test_case : kNestedFunctionsTestCases40ColumnsLimit) { - VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; - std::ostringstream stream; - const auto status = - FormatVerilog(test_case.input, "<filename>", style, stream); - // Require these test cases to be valid. - EXPECT_OK(status) << status.message(); - EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; - } -} - -static constexpr FormatterTestCase kNestedFunctionsTestCases60ColumnsLimit[] = { - {"module foo;" - "`uvm_info(`gfn, $sformatf(\n" - "\"\\n base_vseq: generate %0d pulse in channel %0d\", cfg.num_pulses, " - "i), UVM_DEBUG)\n" - "endmodule", - "module foo;\n" - " `uvm_info(\n" - " `gfn,\n" - " $sformatf(\n" - " \"\\n base_vseq: generate %0d pulse in channel %0d\",\n" - " cfg.num_pulses, i), UVM_DEBUG)\n" - "endmodule\n"}, - {"module foo;`uvm_info(`gfn, $sformatf(" - "\"\\n\\n\\t ----| STARTING AES MAIN SEQUENCE |----\\n %s\"," - "cfg.convert2string()), UVM_LOW)\n" - "endmodule", - "module foo;\n" - " `uvm_info(\n" - " `gfn,\n" - " $sformatf(\n" - " \"\\n\\n\\t ----| STARTING AES MAIN SEQUENCE |----\\n %s\",\n" - " cfg.convert2string()), UVM_LOW)\n" - "endmodule\n"}, -}; - -TEST(FormatterEndToEndTest, FormatNestedFunctionsTestCases60ColumnsLimit) { - // Use a fixed style. - FormatStyle style; - style.column_limit = 60; - style.indentation_spaces = 2; - style.wrap_spaces = 4; - - for (const auto &test_case : kNestedFunctionsTestCases60ColumnsLimit) { - VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; - std::ostringstream stream; - const auto status = - FormatVerilog(test_case.input, "<filename>", style, stream); - // Require these test cases to be valid. - EXPECT_OK(status) << status.message(); - EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; - } -} - -static constexpr FormatterTestCase kNestedFunctionsTestCases80ColumnsLimit[] = { - {"module foo;" - "`uvm_info(`gfn, $sformatf(\n" - "\"\\n base_vseq: generate %0d pulse in channel %0d\", cfg.num_pulses, " - "i), UVM_DEBUG)\n" - "endmodule", - "module foo;\n" - " `uvm_info(`gfn, $sformatf(\"\\n base_vseq: generate %0d pulse in " - "channel %0d\",\n" - " cfg.num_pulses, i), UVM_DEBUG)\n" - "endmodule\n"}, - {"module foo;`uvm_info(`gfn, $sformatf(" - "\"\\n\\n\\t ----| STARTING AES MAIN SEQUENCE |----\\n %s\"," - "cfg.convert2string()), UVM_LOW)\n" - "endmodule", - "module foo;\n" - " `uvm_info(`gfn, $sformatf(\n" - " \"\\n\\n\\t ----| STARTING AES MAIN SEQUENCE " - "|----\\n %s\",\n" - " cfg.convert2string()), UVM_LOW)\nendmodule\n"}, - {"module x;" - "`uvm_fatal(`gfn, $sformatf(" - "\"The data 0x%0h written to the signature address is formatted " - "incorrectly.\"," - "signature_data))\n" - "endmodule", - "module x;\n" - " `uvm_fatal(\n" - " `gfn,\n" - " $sformatf(\n" - " \"The data 0x%0h written to the signature address is formatted " - "incorrectly.\",\n" - " signature_data))\n" - "endmodule\n"}, -}; - -TEST(FormatterEndToEndTest, FormatNestedFunctionsTestCases80ColumnsLimit) { - // Use a fixed style. - FormatStyle style; - style.column_limit = 80; - style.indentation_spaces = 2; - style.wrap_spaces = 4; - - for (const auto &test_case : kNestedFunctionsTestCases80ColumnsLimit) { - VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; - std::ostringstream stream; - const auto status = - FormatVerilog(test_case.input, "<filename>", style, stream); - // Require these test cases to be valid. - EXPECT_OK(status) << status.message(); - EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; - } -} - -static constexpr FormatterTestCase kNestedFunctionsTestCases100ColumnsLimit[] = - { - {"module foo;" - "`uvm_info(`gfn, $sformatf(\n" - "\"\\n base_vseq: generate %0d pulse in channel %0d\", " - "cfg.num_pulses, i), UVM_DEBUG)\n" - "endmodule", - "module foo;\n" - " `uvm_info(`gfn, $sformatf(\"\\n base_vseq: generate %0d pulse in " - "channel %0d\", cfg.num_pulses, i),\n" - " UVM_DEBUG)\n" - "endmodule\n"}, - {"module foo;`uvm_info(`gfn, $sformatf(" - "\"\\n\\n\\t ----| STARTING AES MAIN SEQUENCE |----\\n %s\"," - "cfg.convert2string()), UVM_LOW)\n" - "endmodule", - "module foo;\n" - " `uvm_info(`gfn, $sformatf(\"\\n\\n\\t ----| STARTING AES MAIN " - "SEQUENCE |----\\n %s\",\n" - " cfg.convert2string()), UVM_LOW)\n" - "endmodule\n"}, - {"module x;" - "`uvm_fatal(`gfn, $sformatf(" - "\"The data 0x%0h written to the signature address is formatted " - "incorrectly.\"," - "signature_data))\n" - "endmodule", - "module x;\n" - " `uvm_fatal(`gfn, $sformatf(\n" - " \"The data 0x%0h written to the signature " - "address is formatted incorrectly.\",\n" - " signature_data))\n" - "endmodule\n"}, - {// nested modules, three-levels - "module x; module y; module z;" - "`uvm_fatal(`gfn, $sformatf(" - "\"The data 0x%0h written to the signature address is formatted " - "incorrectly.\"," - "signature_data))\n" - "endmodule endmodule endmodule", - "module x;\n" - " module y;\n" - " module z;\n" - " `uvm_fatal(`gfn,\n" - " $sformatf(\n" - " \"The data 0x%0h written to the signature " - "address is formatted incorrectly.\",\n" - " signature_data))\n" - " endmodule\n" - " endmodule\n" - "endmodule\n"}, -}; - -TEST(FormatterEndToEndTest, FormatNestedFunctionsTestCases100ColumnsLimit) { - // Use a fixed style. - FormatStyle style; - style.column_limit = 100; - style.indentation_spaces = 2; - style.wrap_spaces = 4; - - for (const auto &test_case : kNestedFunctionsTestCases100ColumnsLimit) { - VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; - std::ostringstream stream; - const auto status = - FormatVerilog(test_case.input, "<filename>", style, stream); - // Require these test cases to be valid. - EXPECT_OK(status) << status.message(); - EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; - } -} - -static constexpr FormatterTestCase noCompactIndexingAndSelectionsTestCases[]{ - {"module m1 ();\n" - " assign s1 = msg[1 : 2 + 3];\n" - " assign s2 = {<<8{msg[1 : 2 + 3]}};\n" - "endmodule\n", - "module m1 ();\n" - " assign s1 = msg[1 : 2 + 3];\n" - " assign s2 = {<< 8{msg[1 : 2 + 3]}};\n" - "endmodule\n"}}; - -TEST(FormatterEndToEndTest, compactIndexingAndSelectionsTestCases) { - // Use a fixed style. - FormatStyle style; - style.column_limit = 100; - style.indentation_spaces = 2; - style.wrap_spaces = 4; - style.compact_indexing_and_selections = false; - - for (const auto &test_case : noCompactIndexingAndSelectionsTestCases) { - VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; - std::ostringstream stream; - const auto status = - FormatVerilog(test_case.input, "<filename>", style, stream); - // Require these test cases to be valid. - EXPECT_OK(status) << status.message(); - EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; - } -} - -static constexpr FormatterTestCase kFunctionCallsWithComments[] = { - {// no comments - "module foo;\n" - "`uvm_info(`gfn, \"xx\",\n" - "cfg.num_pulses, i, UVM_DEBUG)\n" - "endmodule", - "module foo;\n" - " `uvm_info(`gfn, \"xx\", cfg.num_pulses, i, UVM_DEBUG)\n" - "endmodule\n"}, - {// one comment - "module foo;\n" - "`uvm_info(`gfn, \"xx\", // yy\n" - "cfg.num_pulses, i, UVM_DEBUG)\n" - "endmodule", - "module foo;\n" - " `uvm_info(`gfn, \"xx\", // yy\n" - " cfg.num_pulses, i, UVM_DEBUG)\n" - "endmodule\n"}, - {// two comments - "module foo;\n" - "`uvm_info(`gfn, \"xx\", " - " cfg.num_pulses, // xx\n" - " i, UVM_DEBUG)// uuu\n" - "endmodule", - "module foo;\n" - " `uvm_info(`gfn, \"xx\", cfg.num_pulses, // xx\n" - " i, UVM_DEBUG) // uuu\n" - "endmodule\n"}, - - {// nested function calls with comments - "module foo;" - "`uvm_info(`gfn, $sformatf(\"\\n base_vseq: generate %0d" - " pulse in channel %0d\", cfg.num_pulses, // comment\n" - " i), UVM_DEBUG)\n" - "endmodule", - "module foo;\n" - " `uvm_info(`gfn, $sformatf(\"\\n base_vseq: generate %0d pulse in " - "channel %0d\",\n" - " cfg.num_pulses, // comment\n" - " i), UVM_DEBUG)\n" - "endmodule\n"}, -}; - -TEST(FormatterEndToEndTest, FunctionCallsWithComments) { - // Use a fixed style. - FormatStyle style; - style.column_limit = 100; - style.indentation_spaces = 2; - style.wrap_spaces = 4; - - for (const auto &test_case : kFunctionCallsWithComments) { - VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; - std::ostringstream stream; - const auto status = - FormatVerilog(test_case.input, "<filename>", style, stream); - // Require these test cases to be valid. - EXPECT_OK(status) << status.message(); - EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; - } -} - -// Extracts the first non-whitespace token and prepends it with number of -// of newlines seen in front of it. So "\n \n\n foo" -> "3foo" -std::string NLCountAndfirstWord(std::string_view str) { - std::string result; - int newline_count = 0; - std::string_view::const_iterator begin = str.begin(); - for (/**/; begin < str.end(); ++begin) { - if (!isspace(*begin)) break; - newline_count += (*begin == '\n'); - } - // Emit number of newlines seen up to first token. - result.append(1, - static_cast<char>(newline_count + '0')); // single digit itoa - std::string_view::const_iterator end_str = begin; - for (/**/; end_str < str.end() && !isspace(*end_str); ++end_str) { - } - result.append(begin, end_str); - return result; -} - -// Similar to NLCountAndfirstWord() but looking at the last token and trailing -// newlines. -std::string lastWordAndNLCount(std::string_view str) { - std::string result; - int newline_count = 0; - std::string_view::const_iterator back = str.end() - 1; - for (/**/; back >= str.begin(); --back) { - if (!isspace(*back)) break; - newline_count += (*back == '\n'); - } - - std::string_view::const_iterator start_str = back; - for (/**/; start_str >= str.begin() && !isspace(*start_str); --start_str) { - } - result.append(&*(start_str + 1), back - start_str); - // Emit number of newlines seen following last token. - result.append(1, - static_cast<char>(newline_count + '0')); // single digit itoa - return result; -} - -// Testing the tester... -TEST(FormatterTestInternal, TokenExtractorAndLineCounterTestFixtureTest) { - std::string_view str = "\n \nhello world \n \n"; - ASSERT_EQ(NLCountAndfirstWord(str), "2hello"); - ASSERT_EQ(NLCountAndfirstWord(str.substr(1)), "1hello"); - ASSERT_EQ(NLCountAndfirstWord(str.substr(3)), "0hello"); - - ASSERT_EQ(lastWordAndNLCount(str), "world2"); - ASSERT_EQ(lastWordAndNLCount(str.substr(0, str.length() - 1)), "world1"); - ASSERT_EQ(lastWordAndNLCount(str.substr(0, str.length() - 2)), "world1"); - ASSERT_EQ(lastWordAndNLCount(str.substr(0, str.length() - 3)), "world0"); - - str = "aworld \n \n"; // Make sure to not overshoot begin. - ASSERT_EQ(lastWordAndNLCount(str.substr(1)), "world2"); -} - -TEST(FormatterEndToEndTest, RangeFormattingOnlyEmittingRelevantLines) { - // Including some empty lines to make sure the formatting - static constexpr std::string_view unformatted = - R"( module foo (// non-port comment - - // some comment - - input logic a, input logic b,input bit [2] -foobar, input bit [4] foobaz, - input bit [2] quux - - - ); endmodule -)"; - - std::vector<std::string_view> lines = absl::StrSplit(unformatted, '\n'); - const int kLineCount = lines.size(); - - FormatStyle style; - - // Go through all possible sub-ranges, format these, and compare that the - // output of the range output is contained inside the full format given the - // same sub-range. - for (int start_line = 0; start_line < kLineCount; ++start_line) { - for (int end_line = start_line; end_line < kLineCount; ++end_line) { - // Line numbers are 1-index based. - const verible::Interval<int> range = {start_line + 1, end_line + 1}; - - // Format full text for reference - std::ostringstream full_format; - absl::Status status = - FormatVerilog(unformatted, "<filename>", style, full_format, {range}); - EXPECT_OK(status) << status.message(); - - // To test: range formatted. - std::string range_formatted; - status = FormatVerilogRange(unformatted, "<filename>", style, - &range_formatted, range); - EXPECT_OK(status) << status.message(); - if (range.empty()) { // Nothing to format: expect empty output. - EXPECT_TRUE(range_formatted.empty()); - continue; - } - - // Area we cover in the input (include the final newline); - const auto source_begin = lines[start_line].begin(); - const auto source_end = lines[end_line - 1].end() + 1; // include \n - const std::string_view range_unformatted(&*source_begin, - source_end - source_begin); - - // To compare that we indeed formatted the requested reqgion, we make - // sure that the first and last token (simplified: non-whitespace word) - // in the input of the range to be formatted is - // exactly the first and last token that comes out of the range - // formatted snippet. - // - // While the whitespace might be different at the beginning and end - // due to formatting, the number of _newlines_ at the beginning and end - // should be the same, so we include the newline count in the comparison. - - EXPECT_EQ(NLCountAndfirstWord(range_unformatted), - NLCountAndfirstWord(range_formatted)) - << "'" << range_unformatted << "' vs. '" << range_formatted << "'"; - - // ... same for the last word. - EXPECT_EQ(lastWordAndNLCount(range_unformatted), - lastWordAndNLCount(range_formatted)) - << "'" << range_unformatted << "' vs. '" << range_formatted << "'"; - - EXPECT_LE(range_formatted.length(), full_format.str().length()); - EXPECT_THAT(full_format.str(), HasSubstr(range_formatted)); - } - } -} - -// Creates a string_view spanning a whole string literal. -// Works correctly with strings containing null bytes. -template <std::size_t N> -constexpr std::string_view string_view_from_literal(const char (&s)[N]) { - return std::string_view(s, N - 1); -} - -// The following regressions have been found by a fuzzer, so the input might -// look a bit 'funny'. Nevertheless, they expose real bugs in the code. - -[[maybe_unused]] void TestForNonCrash(std::string_view input) { - using verible::EscapeString; - FormatStyle style; - std::ostringstream stream; - const auto status = FormatVerilog(input, "<filename>", style, stream); - // If we are here, we did at least not crash, which is all we desire for - // the fuzzer tests. - // Other issues that are reported correctly (probably due to strange inputs - // generated by the fuzzer) are ok, so we just log them here FYI. - if (!status.ok()) { - LOG(INFO) << "No crash, but format failed for other reason: " - << status.message() << "\nEscaped input: \"" - << EscapeString(input) << "\""; - } -} - -#if 0 -// https://github.com/chipsalliance/verible/issues/1381 -TEST(FormatterEndToEndTest, FuzzingRegression_1381) { - TestForNonCrash(string_view_from_literal("P#(\0\0//\0//\0,);")); - TestForNonCrash(string_view_from_literal("P#(\0\0//\0,,//\0,")); -} -#endif - -// https://github.com/chipsalliance/verible/issues/1384 -TEST(FormatterEndToEndTest, FuzzingRegression_UseAfterFree_1384) { - TestForNonCrash("`c(`c(//););"); -} - -// https://github.com/chipsalliance/verible/issues/1386 -TEST(FormatterEndToEndTest, FuzzingRegressionHierachyInvariant) { - // Original sample input from fuzzer - TestForNonCrash(string_view_from_literal("`c(`c()\0;);")); - // Lexically correct variant (`\0` -> `\n`) - TestForNonCrash(string_view_from_literal("`c(`c()\n;);")); - // Lexically correct variant (`\0` removed) - TestForNonCrash(string_view_from_literal("`c(`c(););")); -} - -// Possibly same ? https://github.com/chipsalliance/verible/issues/1386 -TEST(FormatterEndToEndTest, FuzzingRegression_outofmemory) { - TestForNonCrash(string_view_from_literal("`f(1'O`f())\n")); -} - -TEST(FormatterEndToEndTest, AlignmentGroupBoundaryNone) { - // Default behavior: separator comments and blank lines do NOT break groups. - static constexpr FormatterTestCase kTestCases[] = { - {// Separator comment does not break alignment group - "module m;\n" - "assign foo = 1'b1;\n" - "assign baar = 1'b0;\n" - "// ============\n" - "assign baaaaz = 1'b1;\n" - "assign c = 1'b0;\n" - "endmodule\n", - "module m;\n" - " assign foo = 1'b1;\n" - " assign baar = 1'b0;\n" - " // ============\n" - " assign baaaaz = 1'b1;\n" - " assign c = 1'b0;\n" - "endmodule\n"}, - }; - FormatStyle style; - style.column_limit = 40; - style.indentation_spaces = 2; - style.wrap_spaces = 4; - style.alignment_group_boundary = AlignmentGroupBoundary::kNone; - style.assignment_statement_alignment = AlignmentPolicy::kAlign; - for (const auto &test_case : kTestCases) { - VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; - std::ostringstream stream; - const auto status = - FormatVerilog(test_case.input, "<filename>", style, stream); - EXPECT_OK(status) << status.message(); - EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; - } -} - -TEST(FormatterEndToEndTest, AlignmentGroupBoundarySeparatorComments) { - static constexpr FormatterTestCase kTestCases[] = { - {// Separator comment breaks alignment group - "module m;\n" - "assign foo = 1'b1;\n" - "assign baar = 1'b0;\n" - "// ============\n" - "assign baaaaz = 1'b1;\n" - "assign c = 1'b0;\n" - "endmodule\n", - "module m;\n" - " assign foo = 1'b1;\n" - " assign baar = 1'b0;\n" - " // ============\n" - " assign baaaaz = 1'b1;\n" - " assign c = 1'b0;\n" - "endmodule\n"}, - {// Dashes separator also breaks - "module m;\n" - "assign foo = 1'b1;\n" - "assign baar = 1'b0;\n" - "// ------------\n" - "assign baaaaz = 1'b1;\n" - "assign c = 1'b0;\n" - "endmodule\n", - "module m;\n" - " assign foo = 1'b1;\n" - " assign baar = 1'b0;\n" - " // ------------\n" - " assign baaaaz = 1'b1;\n" - " assign c = 1'b0;\n" - "endmodule\n"}, - {// Captioned divider (text between separator runs) also breaks - "module m;\n" - "assign foo = 1'b1;\n" - "assign baar = 1'b0;\n" - "// ------ section heading ------\n" - "assign baaaaz = 1'b1;\n" - "assign c = 1'b0;\n" - "endmodule\n", - "module m;\n" - " assign foo = 1'b1;\n" - " assign baar = 1'b0;\n" - " // ------ section heading ------\n" - " assign baaaaz = 1'b1;\n" - " assign c = 1'b0;\n" - "endmodule\n"}, - {// Leading-only divider run with trailing caption text - "module m;\n" - "assign foo = 1'b1;\n" - "assign baar = 1'b0;\n" - "// ==== Registers\n" - "assign baaaaz = 1'b1;\n" - "assign c = 1'b0;\n" - "endmodule\n", - "module m;\n" - " assign foo = 1'b1;\n" - " assign baar = 1'b0;\n" - " // ==== Registers\n" - " assign baaaaz = 1'b1;\n" - " assign c = 1'b0;\n" - "endmodule\n"}, - {// No space after // also works - "module m;\n" - "assign foo = 1'b1;\n" - "assign baar = 1'b0;\n" - "//============\n" - "assign baaaaz = 1'b1;\n" - "assign c = 1'b0;\n" - "endmodule\n", - "module m;\n" - " assign foo = 1'b1;\n" - " assign baar = 1'b0;\n" - " //============\n" - " assign baaaaz = 1'b1;\n" - " assign c = 1'b0;\n" - "endmodule\n"}, - {// Slash separator (/////) also works - "module m;\n" - "assign foo = 1'b1;\n" - "assign baar = 1'b0;\n" - "//////////\n" - "assign baaaaz = 1'b1;\n" - "assign c = 1'b0;\n" - "endmodule\n", - "module m;\n" - " assign foo = 1'b1;\n" - " assign baar = 1'b0;\n" - " //////////\n" - " assign baaaaz = 1'b1;\n" - " assign c = 1'b0;\n" - "endmodule\n"}, - {// Regular comment does NOT break alignment - "module m;\n" - "assign foo = 1'b1;\n" - "assign baar = 1'b0;\n" - "// Title text\n" - "assign baaaaz = 1'b1;\n" - "assign c = 1'b0;\n" - "endmodule\n", - "module m;\n" - " assign foo = 1'b1;\n" - " assign baar = 1'b0;\n" - " // Title text\n" - " assign baaaaz = 1'b1;\n" - " assign c = 1'b0;\n" - "endmodule\n"}, - {// Multi-line comment block with separators - "module m;\n" - "assign foo = 1'b1;\n" - "assign baar = 1'b0;\n" - "// ============\n" - "// Title\n" - "// ============\n" - "assign baaaaz = 1'b1;\n" - "assign c = 1'b0;\n" - "endmodule\n", - "module m;\n" - " assign foo = 1'b1;\n" - " assign baar = 1'b0;\n" - " // ============\n" - " // Title\n" - " // ============\n" - " assign baaaaz = 1'b1;\n" - " assign c = 1'b0;\n" - "endmodule\n"}, - {// Short repeated body (3 chars) does NOT break - "module m;\n" - "assign foo = 1'b1;\n" - "assign baar = 1'b0;\n" - "// ---\n" - "assign baaaaz = 1'b1;\n" - "assign c = 1'b0;\n" - "endmodule\n", - "module m;\n" - " assign foo = 1'b1;\n" - " assign baar = 1'b0;\n" - " // ---\n" - " assign baaaaz = 1'b1;\n" - " assign c = 1'b0;\n" - "endmodule\n"}, - {// Declarations also respect separator comments - "module m;\n" - "logic a;\n" - "logic [7:0] b;\n" - "// ============\n" - "logic c_long_name;\n" - "logic d;\n" - "endmodule\n", - "module m;\n" - " logic a;\n" - " logic [7:0] b;\n" - " // ============\n" - " logic c_long_name;\n" - " logic d;\n" - "endmodule\n"}, - {// Statements in always blocks - "module m;\n" - "always_comb begin\n" - "aaaaa = b;\n" - "c = 1'b0;\n" - "// ============\n" - "dd = eee;\n" - "ffffff = g;\n" - "end\n" - "endmodule\n", - "module m;\n" - " always_comb begin\n" - " aaaaa = b;\n" - " c = 1'b0;\n" - " // ============\n" - " dd = eee;\n" - " ffffff = g;\n" - " end\n" - "endmodule\n"}, - }; - FormatStyle style; - style.column_limit = 40; - style.indentation_spaces = 2; - style.wrap_spaces = 4; - style.alignment_group_boundary = AlignmentGroupBoundary::kSeparatorComments; - style.assignment_statement_alignment = AlignmentPolicy::kAlign; - style.module_net_variable_alignment = AlignmentPolicy::kAlign; - for (const auto &test_case : kTestCases) { - VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; - std::ostringstream stream; - const auto status = - FormatVerilog(test_case.input, "<filename>", style, stream); - EXPECT_OK(status) << status.message(); - EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; - } -} - -TEST(FormatterEndToEndTest, AlignmentGroupBoundaryBlankLines) { - static constexpr FormatterTestCase kTestCases[] = { - {// Blank line breaks alignment group - "module m;\n" - "assign foo = 1'b1;\n" - "assign baar = 1'b0;\n" - "\n" - "assign baaaaz = 1'b1;\n" - "assign c = 1'b0;\n" - "endmodule\n", - "module m;\n" - " assign foo = 1'b1;\n" - " assign baar = 1'b0;\n" - "\n" - " assign baaaaz = 1'b1;\n" - " assign c = 1'b0;\n" - "endmodule\n"}, - {// No blank line: single alignment group - "module m;\n" - "assign foo = 1'b1;\n" - "assign baar = 1'b0;\n" - "assign baaaaz = 1'b1;\n" - "assign c = 1'b0;\n" - "endmodule\n", - "module m;\n" - " assign foo = 1'b1;\n" - " assign baar = 1'b0;\n" - " assign baaaaz = 1'b1;\n" - " assign c = 1'b0;\n" - "endmodule\n"}, - {// Single item before blank line (not enough for alignment) - "module m;\n" - "assign foo = 1'b1;\n" - "\n" - "assign baaaaz = 1'b1;\n" - "assign c = 1'b0;\n" - "endmodule\n", - "module m;\n" - " assign foo = 1'b1;\n" - "\n" - " assign baaaaz = 1'b1;\n" - " assign c = 1'b0;\n" - "endmodule\n"}, - {// Separator comment does NOT break (only blank lines) - "module m;\n" - "assign foo = 1'b1;\n" - "assign baar = 1'b0;\n" - "// ============\n" - "assign baaaaz = 1'b1;\n" - "assign c = 1'b0;\n" - "endmodule\n", - "module m;\n" - " assign foo = 1'b1;\n" - " assign baar = 1'b0;\n" - " // ============\n" - " assign baaaaz = 1'b1;\n" - " assign c = 1'b0;\n" - "endmodule\n"}, - }; - FormatStyle style; - style.column_limit = 40; - style.indentation_spaces = 2; - style.wrap_spaces = 4; - style.alignment_group_boundary = AlignmentGroupBoundary::kBlankLines; - style.assignment_statement_alignment = AlignmentPolicy::kAlign; - for (const auto &test_case : kTestCases) { - VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; - std::ostringstream stream; - const auto status = - FormatVerilog(test_case.input, "<filename>", style, stream); - EXPECT_OK(status) << status.message(); - EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; - } -} - -TEST(FormatterEndToEndTest, - AlignmentGroupBoundaryBlankLinesAndSeparatorComments) { - static constexpr FormatterTestCase kTestCases[] = { - {// Both blank line and separator break groups - "module m;\n" - "assign foo = 1'b1;\n" - "assign baar = 1'b0;\n" - "\n" - "assign baaaaz = 1'b1;\n" - "assign c = 1'b0;\n" - "// ============\n" - "assign dd = 1'b1;\n" - "assign eee = 1'b0;\n" - "endmodule\n", - "module m;\n" - " assign foo = 1'b1;\n" - " assign baar = 1'b0;\n" - "\n" - " assign baaaaz = 1'b1;\n" - " assign c = 1'b0;\n" - " // ============\n" - " assign dd = 1'b1;\n" - " assign eee = 1'b0;\n" - "endmodule\n"}, - }; - FormatStyle style; - style.column_limit = 40; - style.indentation_spaces = 2; - style.wrap_spaces = 4; - style.alignment_group_boundary = - AlignmentGroupBoundary::kBlankLinesAndSeparatorComments; - style.assignment_statement_alignment = AlignmentPolicy::kAlign; - for (const auto &test_case : kTestCases) { - VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; - std::ostringstream stream; - const auto status = - FormatVerilog(test_case.input, "<filename>", style, stream); - EXPECT_OK(status) << status.message(); - EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; - } -} - -// Regression for https://github.com/chipsalliance/verible/issues/2540: -// Trailing EOL comment after `end` before `else if` must not change whether -// the else-if assignment stays on one line across re-format (convergence). -TEST(FormatterEndToEndTest, EndElseIfWithEOLCommentConverges) { - static constexpr FormatterTestCase kTestCases[] = { - {// Comment on its own line between end and else if - "module m;\n" - " always_comb begin\n" - " case (state)\n" - " STATE_A: begin\n" - " if (cond_aaaa) next_state_value = STATE_B;\n" - " else if (cond_bbbb) begin\n" - " next_state_value = STATE_B;\n" - " end\n" - " // xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n" - " else if (cond_cccc) next_state_value = STATE_C;\n" - " end\n" - " endcase\n" - " end\n" - "endmodule\n", - "module m;\n" - " always_comb begin\n" - " case (state)\n" - " STATE_A: begin\n" - " if (cond_aaaa) next_state_value = STATE_B;\n" - " else if (cond_bbbb) begin\n" - " next_state_value = STATE_B;\n" - " end // xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n" - " else if (cond_cccc) next_state_value = STATE_C;\n" - " end\n" - " endcase\n" - " end\n" - "endmodule\n"}, - {// Same construct with comment already on the end line - "module m;\n" - " always_comb begin\n" - " case (state)\n" - " STATE_A: begin\n" - " if (cond_aaaa) next_state_value = STATE_B;\n" - " else if (cond_bbbb) begin\n" - " next_state_value = STATE_B;\n" - " end // xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n" - " else if (cond_cccc) next_state_value = STATE_C;\n" - " end\n" - " endcase\n" - " end\n" - "endmodule\n", - "module m;\n" - " always_comb begin\n" - " case (state)\n" - " STATE_A: begin\n" - " if (cond_aaaa) next_state_value = STATE_B;\n" - " else if (cond_bbbb) begin\n" - " next_state_value = STATE_B;\n" - " end // xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n" - " else if (cond_cccc) next_state_value = STATE_C;\n" - " end\n" - " endcase\n" - " end\n" - "endmodule\n"}, - }; - FormatStyle style; // default column_limit (100) - for (const auto &test_case : kTestCases) { - VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; - std::ostringstream stream; - const auto status = - FormatVerilog(test_case.input, "<filename>", style, stream); - EXPECT_OK(status) << status.message(); - EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; - } -} - -// Verify kAlign behavior for body-level param/localparam declarations -// in module and package bodies. -TEST(FormatterEndToEndTest, ParamDeclarationAlignmentBasics) { - static constexpr FormatterTestCase kTestCases[] = { - {// localparam alignment in module body - "module m;\n" - "localparam foo = 4'b0000;\n" - "localparam barr = 4'b0010;\n" - "localparam baaaaz = 4'b0111;\n" - "endmodule\n", - "module m;\n" - " localparam foo = 4'b0000;\n" - " localparam barr = 4'b0010;\n" - " localparam baaaaz = 4'b0111;\n" - "endmodule\n"}, - {// localparam alignment in package body - "package p;\n" - "localparam foo = 4'b0000;\n" - "localparam barr = 4'b0010;\n" - "localparam baaaaz = 4'b0111;\n" - "endpackage\n", - "package p;\n" - " localparam foo = 4'b0000;\n" - " localparam barr = 4'b0010;\n" - " localparam baaaaz = 4'b0111;\n" - "endpackage\n"}, - {// parameter alignment in module body - "module m;\n" - "parameter int foo = 1;\n" - "parameter int barr = 2;\n" - "endmodule\n", - "module m;\n" - " parameter int foo = 1;\n" - " parameter int barr = 2;\n" - "endmodule\n"}, - {// parameter alignment in package body - "package p;\n" - "parameter int foo = 1;\n" - "parameter int barrrr = 2;\n" - "endpackage\n", - "package p;\n" - " parameter int foo = 1;\n" - " parameter int barrrr = 2;\n" - "endpackage\n"}, - }; - FormatStyle style; - style.column_limit = 40; - style.indentation_spaces = 2; - style.wrap_spaces = 4; - style.parameter_declaration_alignment = AlignmentPolicy::kAlign; - for (const auto &test_case : kTestCases) { - VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; - std::ostringstream stream; - const auto status = - FormatVerilog(test_case.input, "<filename>", style, stream); - EXPECT_OK(status) << status.message(); - EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; - } -} - -// Verify kFlushLeft behavior: body-level param/localparam declarations -// are not aligned. -TEST(FormatterEndToEndTest, ParamDeclarationAlignmentFlushLeft) { - static constexpr FormatterTestCase kTestCases[] = { - {// module body: parameters are not aligned - "module m;\n" - "localparam foo = 4'b0000;\n" - "localparam barr = 4'b0010;\n" - "endmodule\n", - "module m;\n" - " localparam foo = 4'b0000;\n" - " localparam barr = 4'b0010;\n" - "endmodule\n"}, - {// package context: flush-left - "package p;\n" - "localparam foo = 4'b0000;\n" - "localparam barr = 4'b0010;\n" - "endpackage\n", - "package p;\n" - " localparam foo = 4'b0000;\n" - " localparam barr = 4'b0010;\n" - "endpackage\n"}, - {// generate context: flush-left - "module m;\n" - "generate\n" - "localparam foo = 1;\n" - "localparam barr = 2;\n" - "endgenerate\n" - "endmodule\n", - "module m;\n" - " generate\n" - " localparam foo = 1;\n" - " localparam barr = 2;\n" - " endgenerate\n" - "endmodule\n"}, - {// parameter in module body: flush-left - "module m;\n" - "parameter int W = 8;\n" - "parameter int HHHH = 2;\n" - "endmodule\n", - "module m;\n" - " parameter int W = 8;\n" - " parameter int HHHH = 2;\n" - "endmodule\n"}, - {// mixed parameter and localparam: flush-left, no alignment - "module m;\n" - "parameter int W = 8;\n" - "localparam L = 4;\n" - "parameter int H = 2;\n" - "endmodule\n", - "module m;\n" - " parameter int W = 8;\n" - " localparam L = 4;\n" - " parameter int H = 2;\n" - "endmodule\n"}, - {// interface context: flush-left - "interface my_if;\n" - "localparam foo = 1;\n" - "localparam barr = 2;\n" - "endinterface\n", - "interface my_if;\n" - " localparam foo = 1;\n" - " localparam barr = 2;\n" - "endinterface\n"}, - }; - FormatStyle style; - style.column_limit = 40; - style.indentation_spaces = 2; - style.wrap_spaces = 4; - style.parameter_declaration_alignment = AlignmentPolicy::kFlushLeft; - for (const auto &test_case : kTestCases) { - VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; - std::ostringstream stream; - const auto status = - FormatVerilog(test_case.input, "<filename>", style, stream); - EXPECT_OK(status) << status.message(); - EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; - } -} - -// Verify kPreserve behavior: body-level param/localparam declarations -// maintain their existing spacing. -TEST(FormatterEndToEndTest, ParamDeclarationAlignmentPreserve) { - static constexpr FormatterTestCase kTestCases[] = { - {// module body: existing spacing is kept - "module m;\n" - "localparam foo = 4'b0000;\n" - "localparam barr = 4'b0010;\n" - "endmodule\n", - "module m;\n" - " localparam foo = 4'b0000;\n" - " localparam barr = 4'b0010;\n" - "endmodule\n"}, - {// package: existing flush-left spacing preserved - "package p;\n" - "localparam foo = 4'b0000;\n" - "localparam barr = 4'b0010;\n" - "endpackage\n", - "package p;\n" - " localparam foo = 4'b0000;\n" - " localparam barr = 4'b0010;\n" - "endpackage\n"}, - {// generate: existing aligned spacing preserved - "module m;\n" - "generate\n" - "localparam foo = 1;\n" - "localparam barr = 2;\n" - "endgenerate\n" - "endmodule\n", - "module m;\n" - " generate\n" - " localparam foo = 1;\n" - " localparam barr = 2;\n" - " endgenerate\n" - "endmodule\n"}, - {// parameter flush-left preserved - "module m;\n" - "parameter int W = 8;\n" - "parameter int HHHH = 2;\n" - "endmodule\n", - "module m;\n" - " parameter int W = 8;\n" - " parameter int HHHH = 2;\n" - "endmodule\n"}, - {// parameter pre-aligned preserved - "module m;\n" - "parameter int W = 8;\n" - "parameter int HHHH = 2;\n" - "endmodule\n", - "module m;\n" - " parameter int W = 8;\n" - " parameter int HHHH = 2;\n" - "endmodule\n"}, - {// interface pre-aligned preserved - "interface my_if;\n" - "localparam foo = 1;\n" - "localparam barr = 2;\n" - "endinterface\n", - "interface my_if;\n" - " localparam foo = 1;\n" - " localparam barr = 2;\n" - "endinterface\n"}, - }; - FormatStyle style; - style.column_limit = 40; - style.indentation_spaces = 2; - style.wrap_spaces = 4; - style.parameter_declaration_alignment = AlignmentPolicy::kPreserve; - for (const auto &test_case : kTestCases) { - VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; - std::ostringstream stream; - const auto status = - FormatVerilog(test_case.input, "<filename>", style, stream); - EXPECT_OK(status) << status.message(); - EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; - } -} - -// Verify kAlign behavior for param/localparam declarations across -// interface, generate, and module body contexts, including mixed -// param/localparam and packed dimension alignment. -TEST(FormatterEndToEndTest, ParamDeclarationAlignmentContexts) { - static constexpr FormatterTestCase kTestCases[] = { - {// interface body localparam alignment - "interface my_if;\n" - "localparam foo = 1;\n" - "localparam barr = 2;\n" - "endinterface\n", - "interface my_if;\n" - " localparam foo = 1;\n" - " localparam barr = 2;\n" - "endinterface\n"}, - {// interface body parameter alignment - "interface my_if;\n" - "parameter int X = 1;\n" - "parameter int Y_LONG = 2;\n" - "endinterface\n", - "interface my_if;\n" - " parameter int X = 1;\n" - " parameter int Y_LONG = 2;\n" - "endinterface\n"}, - {// generate block localparam alignment - "module m;\n" - "generate\n" - "localparam foo = 1;\n" - "localparam barr = 2;\n" - "endgenerate\n" - "endmodule\n", - "module m;\n" - " generate\n" - " localparam foo = 1;\n" - " localparam barr = 2;\n" - " endgenerate\n" - "endmodule\n"}, - {// generate block parameter alignment - "module m;\n" - "generate\n" - "parameter int A = 1;\n" - "parameter int BB = 2;\n" - "endgenerate\n" - "endmodule\n", - "module m;\n" - " generate\n" - " parameter int A = 1;\n" - " parameter int BB = 2;\n" - " endgenerate\n" - "endmodule\n"}, - {// mixed param and net declarations form separate alignment groups - "module m;\n" - "localparam X = 1;\n" - "localparam YYY = 2;\n" - "logic clk;\n" - "logic rst_n;\n" - "localparam ZZ = 3;\n" - "endmodule\n", - "module m;\n" - " localparam X = 1;\n" - " localparam YYY = 2;\n" - " logic clk;\n" - " logic rst_n;\n" - " localparam ZZ = 3;\n" - "endmodule\n"}, - {// mixed parameter and localparam in same block - "module m;\n" - "parameter int W = 8;\n" - "localparam L = 4;\n" - "parameter int H = 2;\n" - "endmodule\n", - "module m;\n" - " parameter int W = 8;\n" - " localparam L = 4;\n" - " parameter int H = 2;\n" - "endmodule\n"}, - {// packed dimensions are aligned - "module m;\n" - "parameter bit [7:0] X = 0;\n" - "parameter bit [31:0] YYYY = 1;\n" - "endmodule\n", - "module m;\n" - " parameter bit [ 7:0] X = 0;\n" - " parameter bit [31:0] YYYY = 1;\n" - "endmodule\n"}, - {// multi-identifier comma-separated params are not split (no-crash) - "module m;\n" - "parameter int a=1, b=2, ccc=3;\n" - "localparam d=4, e=5;\n" - "endmodule\n", - "module m;\n" - " parameter int a = 1, b = 2, ccc = 3;\n" - " localparam d = 4, e = 5;\n" - "endmodule\n"}, - {// parameter type declarations do not crash - "module m;\n" - "parameter type T = int;\n" - "parameter type TT_LONG = bit;\n" - "endmodule\n", - "module m;\n" - " parameter type T = int;\n" - " parameter type TT_LONG = bit;\n" - "endmodule\n"}, - }; - FormatStyle style; - style.column_limit = 40; - style.indentation_spaces = 2; - style.wrap_spaces = 4; - style.parameter_declaration_alignment = AlignmentPolicy::kAlign; - for (const auto &test_case : kTestCases) { - VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; - std::ostringstream stream; - const auto status = - FormatVerilog(test_case.input, "<filename>", style, stream); - EXPECT_OK(status) << status.message(); - EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; - } -} - -// Verify kInferUserIntent behavior: body-level param/localparam -// declarations infer alignment intent from existing spacing. -TEST(FormatterEndToEndTest, ParamDeclarationAlignmentInferUserIntent) { - static constexpr FormatterTestCase kTestCases[] = { - {// flush-left localparams with small spacing diff: infer aligns - "module m;\n" - "localparam foo = 1;\n" - "localparam barr = 2;\n" - "endmodule\n", - "module m;\n" - " localparam foo = 1;\n" - " localparam barr = 2;\n" - "endmodule\n"}, - {// pre-aligned localparams: infer preserves alignment - "module m;\n" - "localparam foo = 1;\n" - "localparam barr = 2;\n" - "localparam baaaaz = 3;\n" - "endmodule\n", - "module m;\n" - " localparam foo = 1;\n" - " localparam barr = 2;\n" - " localparam baaaaz = 3;\n" - "endmodule\n"}, - {// flush-left params in package with small spacing diff: infer aligns - "package p;\n" - "localparam X = 1;\n" - "localparam YY = 2;\n" - "endpackage\n", - "package p;\n" - " localparam X = 1;\n" - " localparam YY = 2;\n" - "endpackage\n"}, - {// mixed param/localparam flush-left: infer keeps flush-left - "module m;\n" - "parameter int W = 8;\n" - "localparam L = 4;\n" - "endmodule\n", - "module m;\n" - " parameter int W = 8;\n" - " localparam L = 4;\n" - "endmodule\n"}, - {// interface flush-left with small diff: infer aligns - "interface my_if;\n" - "localparam foo = 1;\n" - "localparam barr = 2;\n" - "endinterface\n", - "interface my_if;\n" - " localparam foo = 1;\n" - " localparam barr = 2;\n" - "endinterface\n"}, - }; - FormatStyle style; - style.column_limit = 40; - style.indentation_spaces = 2; - style.wrap_spaces = 4; - style.parameter_declaration_alignment = AlignmentPolicy::kInferUserIntent; - for (const auto &test_case : kTestCases) { - VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; - std::ostringstream stream; - const auto status = - FormatVerilog(test_case.input, "<filename>", style, stream); - EXPECT_OK(status) << status.message(); - EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; - } -} - -// Verify boundary behavior for param declarations with -// kBlankLinesAndSeparatorComments: both blank lines and separator comments -// break alignment groups. -TEST(FormatterEndToEndTest, ParamDeclarationAlignmentBoundary) { - static constexpr FormatterTestCase kTestCases[] = { - {// separator comment breaks param alignment group - "module m;\n" - "localparam foo = 1;\n" - "localparam barr = 2;\n" - "// ============\n" - "localparam baaaaz = 1;\n" - "localparam c = 2;\n" - "endmodule\n", - "module m;\n" - " localparam foo = 1;\n" - " localparam barr = 2;\n" - " // ============\n" - " localparam baaaaz = 1;\n" - " localparam c = 2;\n" - "endmodule\n"}, - {// blank line breaks param alignment group - "module m;\n" - "localparam foo = 1;\n" - "localparam barr = 2;\n" - "\n" - "localparam baaaaz = 1;\n" - "localparam c = 2;\n" - "endmodule\n", - "module m;\n" - " localparam foo = 1;\n" - " localparam barr = 2;\n" - "\n" - " localparam baaaaz = 1;\n" - " localparam c = 2;\n" - "endmodule\n"}, - {// no separator: single alignment group (all aligned together) - "module m;\n" - "localparam foo = 1;\n" - "localparam barr = 2;\n" - "localparam baaaaz = 1;\n" - "localparam c = 2;\n" - "endmodule\n", - "module m;\n" - " localparam foo = 1;\n" - " localparam barr = 2;\n" - " localparam baaaaz = 1;\n" - " localparam c = 2;\n" - "endmodule\n"}, - {// regular comment does NOT break alignment group - "module m;\n" - "localparam foo = 1;\n" - "// regular comment\n" - "localparam barr = 2;\n" - "localparam baaaaz = 1;\n" - "endmodule\n", - "module m;\n" - " localparam foo = 1;\n" - " // regular comment\n" - " localparam barr = 2;\n" - " localparam baaaaz = 1;\n" - "endmodule\n"}, - }; - FormatStyle style; - style.column_limit = 40; - style.indentation_spaces = 2; - style.wrap_spaces = 4; - style.parameter_declaration_alignment = AlignmentPolicy::kAlign; - style.alignment_group_boundary = - AlignmentGroupBoundary::kBlankLinesAndSeparatorComments; - for (const auto &test_case : kTestCases) { - VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; - std::ostringstream stream; - const auto status = - FormatVerilog(test_case.input, "<filename>", style, stream); - EXPECT_OK(status) << status.message(); - EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; - } -} - -// Verify edge cases: unpacked dimensions, signed/unsigned, implicit types, -// complex types, single declarations, deeply nested generate blocks. -TEST(FormatterEndToEndTest, ParamDeclarationAlignmentEdgeCases) { - // Use column_limit = 80 to avoid unintended line wrapping inside - // deeply nested generate blocks (generate-if, generate-for), which - // would interfere with verifying alignment behavior. - static constexpr FormatterTestCase kTestCases[] = { - {// unpacked dimension alignment - "module m;\n" - "parameter bit X [7:0] = 0;\n" - "parameter bit YYYY [15:0] = 1;\n" - "endmodule\n", - "module m;\n" - " parameter bit X [ 7:0] = 0;\n" - " parameter bit YYYY[15:0] = 1;\n" - "endmodule\n"}, - {// param declarations with only type and default value (no idim) - "module m;\n" - "parameter int X = 0;\n" - "parameter int YYYY = 0;\n" - "endmodule\n", - "module m;\n" - " parameter int X = 0;\n" - " parameter int YYYY = 0;\n" - "endmodule\n"}, - {// signed modifier with packed dimensions - "module m;\n" - "parameter bit signed [7:0] X = 0;\n" - "parameter bit signed [31:0] YYYY = 1;\n" - "endmodule\n", - "module m;\n" - " parameter bit signed [ 7:0] X = 0;\n" - " parameter bit signed [31:0] YYYY = 1;\n" - "endmodule\n"}, - {// param with complex type (struct/typedef) — does not crash - "module m;\n" - "parameter foo_t X = foo_t'(0);\n" - "parameter foo_t Y_LONG = foo_t'(0);\n" - "endmodule\n", - "module m;\n" - " parameter foo_t X = foo_t'(0);\n" - " parameter foo_t Y_LONG = foo_t'(0);\n" - "endmodule\n"}, - {// single param declaration (not enough for alignment group) - "module m;\n" - "localparam X = 1;\n" - "endmodule\n", - "module m;\n" - " localparam X = 1;\n" - "endmodule\n"}, - {// params inside generate-if block - "module m;\n" - "generate\n" - "if (1) begin : blk\n" - "localparam foo = 1;\n" - "localparam barr = 2;\n" - "end\n" - "endgenerate\n" - "endmodule\n", - "module m;\n" - " generate\n" - " if (1) begin : blk\n" - " localparam foo = 1;\n" - " localparam barr = 2;\n" - " end\n" - " endgenerate\n" - "endmodule\n"}, - {// unsigned keyword with packed dimensions (complement to signed) - "module m;\n" - "parameter bit unsigned [7:0] X = 0;\n" - "parameter bit unsigned [31:0] YYYY = 1;\n" - "endmodule\n", - "module m;\n" - " parameter bit unsigned [ 7:0] X = 0;\n" - " parameter bit unsigned [31:0] YYYY = 1;\n" - "endmodule\n"}, - {// parameter with implicit type (no explicit type keyword) - "module m;\n" - "parameter X = 32;\n" - "parameter Y_LONG = 64;\n" - "endmodule\n", - "module m;\n" - " parameter X = 32;\n" - " parameter Y_LONG = 64;\n" - "endmodule\n"}, - {// params inside generate-for block - "module m;\n" - "generate\n" - "for (i = 0; i < 2; i++) begin : blk\n" - "localparam foo = 1;\n" - "localparam barr = 2;\n" - "end\n" - "endgenerate\n" - "endmodule\n", - "module m;\n" - " generate\n" - " for (i = 0; i < 2; i++) begin : blk\n" - " localparam foo = 1;\n" - " localparam barr = 2;\n" - " end\n" - " endgenerate\n" - "endmodule\n"}, - }; - FormatStyle style; - style.column_limit = 80; - style.indentation_spaces = 2; - style.wrap_spaces = 4; - style.parameter_declaration_alignment = AlignmentPolicy::kAlign; - for (const auto &test_case : kTestCases) { - VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; - std::ostringstream stream; - const auto status = - FormatVerilog(test_case.input, "<filename>", style, stream); - EXPECT_OK(status) << status.message(); - EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; - } -} - -// Verify parameter declarations inside generate-case blocks are aligned. -TEST(FormatterEndToEndTest, ParamDeclarationAlignmentGenerateCase) { - // Params inside generate-case need wider column limit to avoid wrapping the - // case label / begin block line. - static constexpr FormatterTestCase kTestCases[] = { - {// params inside generate-case block - "module m #(P = 0);\n" - "generate\n" - "case (P)\n" - "0: begin : blk\n" - "localparam foo = 1;\n" - "localparam barr = 2;\n" - "end\n" - "endcase\n" - "endgenerate\n" - "endmodule\n", - "module m #(\n" - " P = 0\n" - ");\n" - " generate\n" - " case (P)\n" - " 0: begin : blk\n" - " localparam foo = 1;\n" - " localparam barr = 2;\n" - " end\n" - " endcase\n" - " endgenerate\n" - "endmodule\n"}, - }; - FormatStyle style; - style.column_limit = 80; - style.indentation_spaces = 2; - style.wrap_spaces = 4; - style.parameter_declaration_alignment = AlignmentPolicy::kAlign; - for (const auto &test_case : kTestCases) { - VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; - std::ostringstream stream; - const auto status = - FormatVerilog(test_case.input, "<filename>", style, stream); - EXPECT_OK(status) << status.message(); - EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; - } -} - -TEST(FormatterEndToEndTest, FormalAndBodyParamAlignmentIndependence) { - // Verify that --formal_parameters_alignment and - // --parameter_declaration_alignment act independently: setting formal params - // to kFlushLeft should not affect body-level param alignment, and vice versa. - static constexpr FormatterTestCase kTestCases[] = { - {// formal flush-left + body align: only body params align - "module m #(\n" - "int W = 2,\n" - "int LLLL = 4\n" - ");\n" - "localparam foo = 0;\n" - "localparam barrrr = 0;\n" - "endmodule\n", - "module m #(\n" - " int W = 2,\n" - " int LLLL = 4\n" - ");\n" - " localparam foo = 0;\n" - " localparam barrrr = 0;\n" - "endmodule\n"}, - {// formal align + body flush-left: only formal params align - "module m #(\n" - "int W = 2,\n" - "int LLLL = 4\n" - ");\n" - "localparam foo = 0;\n" - "localparam barrrr = 0;\n" - "endmodule\n", - "module m #(\n" - " int W = 2,\n" - " int LLLL = 4\n" - ");\n" - " localparam foo = 0;\n" - " localparam barrrr = 0;\n" - "endmodule\n"}, - {// both flush-left: no alignment anywhere - "module m #(\n" - "int W = 2,\n" - "int LLLL = 4\n" - ");\n" - "localparam foo = 0;\n" - "localparam barrrr = 0;\n" - "endmodule\n", - "module m #(\n" - " int W = 2,\n" - " int LLLL = 4\n" - ");\n" - " localparam foo = 0;\n" - " localparam barrrr = 0;\n" - "endmodule\n"}, - {// both align: both formal and body params aligned - "module m #(\n" - "int W = 2,\n" - "int LLLL = 4\n" - ");\n" - "localparam foo = 0;\n" - "localparam barrrr = 0;\n" - "endmodule\n", - "module m #(\n" - " int W = 2,\n" - " int LLLL = 4\n" - ");\n" - " localparam foo = 0;\n" - " localparam barrrr = 0;\n" - "endmodule\n"}, - }; - // First case: formal kFlushLeft, body kAlign - { - FormatStyle style; - style.column_limit = 40; - style.indentation_spaces = 2; - style.wrap_spaces = 4; - style.parameter_declaration_alignment = AlignmentPolicy::kAlign; - style.formal_parameters_alignment = AlignmentPolicy::kFlushLeft; - const auto &tc = kTestCases[0]; - VLOG(1) << "code-to-format:\n" << tc.input << "<EOF>"; - std::ostringstream stream; - const auto status = FormatVerilog(tc.input, "<filename>", style, stream); - EXPECT_OK(status) << status.message(); - EXPECT_EQ(stream.str(), tc.expected) << "code:\n" << tc.input; - } - // Second case: formal kAlign, body kFlushLeft - { - FormatStyle style; - style.column_limit = 40; - style.indentation_spaces = 2; - style.wrap_spaces = 4; - style.parameter_declaration_alignment = AlignmentPolicy::kFlushLeft; - style.formal_parameters_alignment = AlignmentPolicy::kAlign; - const auto &tc = kTestCases[1]; - VLOG(1) << "code-to-format:\n" << tc.input << "<EOF>"; - std::ostringstream stream; - const auto status = FormatVerilog(tc.input, "<filename>", style, stream); - EXPECT_OK(status) << status.message(); - EXPECT_EQ(stream.str(), tc.expected) << "code:\n" << tc.input; - } - // Third case: both kFlushLeft - { - FormatStyle style; - style.column_limit = 40; - style.indentation_spaces = 2; - style.wrap_spaces = 4; - style.parameter_declaration_alignment = AlignmentPolicy::kFlushLeft; - style.formal_parameters_alignment = AlignmentPolicy::kFlushLeft; - const auto &tc = kTestCases[2]; - VLOG(1) << "code-to-format:\n" << tc.input << "<EOF>"; - std::ostringstream stream; - const auto status = FormatVerilog(tc.input, "<filename>", style, stream); - EXPECT_OK(status) << status.message(); - EXPECT_EQ(stream.str(), tc.expected) << "code:\n" << tc.input; - } - // Fourth case: both kAlign - { - FormatStyle style; - style.column_limit = 40; - style.indentation_spaces = 2; - style.wrap_spaces = 4; - style.parameter_declaration_alignment = AlignmentPolicy::kAlign; - style.formal_parameters_alignment = AlignmentPolicy::kAlign; - const auto &tc = kTestCases[3]; - VLOG(1) << "code-to-format:\n" << tc.input << "<EOF>"; - std::ostringstream stream; - const auto status = FormatVerilog(tc.input, "<filename>", style, stream); - EXPECT_OK(status) << status.message(); - EXPECT_EQ(stream.str(), tc.expected) << "code:\n" << tc.input; - } -} - -TEST(FormatterEndToEndTest, ClassBodyParamNotAffected) { - // Verify that class body parameter/localparam declarations are NOT affected - // by --parameter_declaration_alignment, which targets only module/generate/ - // package/interface body-level params. - static constexpr FormatterTestCase kTestCases[] = { - {// class body params are not affected - "class c;\n" - "parameter int X = 1;\n" - "parameter int YYYY = 2;\n" - "localparam foo = 3;\n" - "localparam barrrr = 4;\n" - "endclass\n", - "class c;\n" - " parameter int X = 1;\n" - " parameter int YYYY = 2;\n" - " localparam foo = 3;\n" - " localparam barrrr = 4;\n" - "endclass\n"}, - }; - FormatStyle style; - style.column_limit = 40; - style.indentation_spaces = 2; - style.wrap_spaces = 4; - style.parameter_declaration_alignment = AlignmentPolicy::kAlign; - for (const auto &test_case : kTestCases) { - VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; - std::ostringstream stream; - const auto status = - FormatVerilog(test_case.input, "<filename>", style, stream); - EXPECT_OK(status) << status.message(); - EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; - } -} - -TEST(FormatterEndToEndTest, PackageBodyVariableAlignment) { - // Verify that moving kPackageItemList to kTabularAlignment in tree-unwrapper - // enables net/variable declaration alignment in package bodies via - // module_net_variable_alignment. - static constexpr FormatterTestCase kTestCases[] = { - {// net/variable declaration alignment in package body - "package p;\n" - "logic [7:0] a;\n" - "logic [31:0] bb;\n" - "endpackage\n", - "package p;\n" - " logic [ 7:0] a;\n" - " logic [31:0] bb;\n" - "endpackage\n"}, - }; - FormatStyle style; - style.column_limit = 40; - style.indentation_spaces = 2; - style.wrap_spaces = 4; - style.module_net_variable_alignment = AlignmentPolicy::kAlign; - for (const auto &test_case : kTestCases) { - VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; - std::ostringstream stream; - const auto status = - FormatVerilog(test_case.input, "<filename>", style, stream); - EXPECT_OK(status) << status.message(); - EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; - } -} - -TEST(FormatterEndToEndTest, ParamDeclarationAlignmentApplyToAll) { - // Verify that ApplyToAllAlignmentPolicies affects - // parameter_declaration_alignment for all four alignment policies. - static constexpr FormatterTestCase kTestCases[] = { - {// kAlign aligns identifiers and = signs across declarations - "module m;\n" - "localparam foo = 1;\n" - "localparam barrrr = 2;\n" - "endmodule\n", - "module m;\n" - " localparam foo = 1;\n" - " localparam barrrr = 2;\n" - "endmodule\n"}, - {// kFlushLeft: declarations remain flush-left - "module m;\n" - "localparam foo = 1;\n" - "localparam barrrr = 2;\n" - "endmodule\n", - "module m;\n" - " localparam foo = 1;\n" - " localparam barrrr = 2;\n" - "endmodule\n"}, - {// kPreserve: existing spacing is kept - "module m;\n" - "localparam foo = 1;\n" - "localparam barrrr = 2;\n" - "endmodule\n", - "module m;\n" - " localparam foo = 1;\n" - " localparam barrrr = 2;\n" - "endmodule\n"}, - {// kInferUserIntent: large identifier width difference (3 cols) - // suggests flush-left intent, no alignment. - "module m;\n" - "localparam foo = 1;\n" - "localparam barrrr = 2;\n" - "endmodule\n", - "module m;\n" - " localparam foo = 1;\n" - " localparam barrrr = 2;\n" - "endmodule\n"}, - }; - // kAlign - { - FormatStyle style; - style.column_limit = 40; - style.indentation_spaces = 2; - style.wrap_spaces = 4; - style.ApplyToAllAlignmentPolicies(AlignmentPolicy::kAlign); - const auto &tc = kTestCases[0]; - std::ostringstream stream; - const auto status = FormatVerilog(tc.input, "<filename>", style, stream); - EXPECT_OK(status) << status.message(); - EXPECT_EQ(stream.str(), tc.expected) << "code:\n" << tc.input; - } - // kFlushLeft - { - FormatStyle style; - style.column_limit = 40; - style.indentation_spaces = 2; - style.wrap_spaces = 4; - style.ApplyToAllAlignmentPolicies(AlignmentPolicy::kFlushLeft); - const auto &tc = kTestCases[1]; - std::ostringstream stream; - const auto status = FormatVerilog(tc.input, "<filename>", style, stream); - EXPECT_OK(status) << status.message(); - EXPECT_EQ(stream.str(), tc.expected) << "code:\n" << tc.input; - } - // kPreserve - { - FormatStyle style; - style.column_limit = 40; - style.indentation_spaces = 2; - style.wrap_spaces = 4; - style.ApplyToAllAlignmentPolicies(AlignmentPolicy::kPreserve); - const auto &tc = kTestCases[2]; - std::ostringstream stream; - const auto status = FormatVerilog(tc.input, "<filename>", style, stream); - EXPECT_OK(status) << status.message(); - EXPECT_EQ(stream.str(), tc.expected) << "code:\n" << tc.input; - } - // kInferUserIntent - { - FormatStyle style; - style.column_limit = 40; - style.indentation_spaces = 2; - style.wrap_spaces = 4; - style.ApplyToAllAlignmentPolicies(AlignmentPolicy::kInferUserIntent); - const auto &tc = kTestCases[3]; - std::ostringstream stream; - const auto status = FormatVerilog(tc.input, "<filename>", style, stream); - EXPECT_OK(status) << status.message(); - EXPECT_EQ(stream.str(), tc.expected) << "code:\n" << tc.input; - } -} - -// Verify that alignment_group_boundary=kBlankLines treats only blank lines -// (not separator comments) as boundary breaks for param declarations. -TEST(FormatterEndToEndTest, ParamDeclarationAlignmentBoundaryBlankLines) { - static constexpr FormatterTestCase kTestCases[] = { - {// Only blank line breaks group; separator comment does not - "module m;\n" - "localparam foo = 1;\n" - "localparam barr = 2;\n" - "\n" - "localparam baaaaz = 1;\n" - "localparam c = 2;\n" - "endmodule\n", - "module m;\n" - " localparam foo = 1;\n" - " localparam barr = 2;\n" - "\n" - " localparam baaaaz = 1;\n" - " localparam c = 2;\n" - "endmodule\n"}, - {// Separator comment does NOT break group with kBlankLines - "module m;\n" - "localparam foo = 1;\n" - "localparam barr = 2;\n" - "// ============\n" - "localparam baaaaz = 1;\n" - "localparam c = 2;\n" - "endmodule\n", - "module m;\n" - " localparam foo = 1;\n" - " localparam barr = 2;\n" - " // ============\n" - " localparam baaaaz = 1;\n" - " localparam c = 2;\n" - "endmodule\n"}, - }; - FormatStyle style; - style.column_limit = 40; - style.indentation_spaces = 2; - style.wrap_spaces = 4; - style.parameter_declaration_alignment = AlignmentPolicy::kAlign; - style.alignment_group_boundary = AlignmentGroupBoundary::kBlankLines; - for (const auto &test_case : kTestCases) { - VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; - std::ostringstream stream; - const auto status = - FormatVerilog(test_case.input, "<filename>", style, stream); - EXPECT_OK(status) << status.message(); - EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; - } -} - -// Verify that alignment_group_boundary=kNone keeps all param declarations -// in a single alignment group regardless of blank lines or comments. -TEST(FormatterEndToEndTest, ParamDeclarationAlignmentBoundaryNone) { - static constexpr FormatterTestCase kTestCases[] = { - {// Blank line does NOT break group with kNone - "module m;\n" - "localparam foo = 1;\n" - "localparam barr = 2;\n" - "\n" - "localparam baaaaz = 1;\n" - "localparam c = 2;\n" - "endmodule\n", - "module m;\n" - " localparam foo = 1;\n" - " localparam barr = 2;\n" - "\n" - " localparam baaaaz = 1;\n" - " localparam c = 2;\n" - "endmodule\n"}, - {// Separator comment does NOT break group with kNone - "module m;\n" - "localparam foo = 1;\n" - "localparam barr = 2;\n" - "// ============\n" - "localparam baaaaz = 1;\n" - "localparam c = 2;\n" - "endmodule\n", - "module m;\n" - " localparam foo = 1;\n" - " localparam barr = 2;\n" - " // ============\n" - " localparam baaaaz = 1;\n" - " localparam c = 2;\n" - "endmodule\n"}, - }; - FormatStyle style; - style.column_limit = 40; - style.indentation_spaces = 2; - style.wrap_spaces = 4; - style.parameter_declaration_alignment = AlignmentPolicy::kAlign; - style.alignment_group_boundary = AlignmentGroupBoundary::kNone; - for (const auto &test_case : kTestCases) { - VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; - std::ostringstream stream; - const auto status = - FormatVerilog(test_case.input, "<filename>", style, stream); - EXPECT_OK(status) << status.message(); - EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; - } -} - -// Verify that alignment_group_boundary=kSeparatorComments treats only -// separator comments (not blank lines) as boundary breaks for param -// declarations. -TEST(FormatterEndToEndTest, - ParamDeclarationAlignmentBoundarySeparatorComments) { - static constexpr FormatterTestCase kTestCases[] = { - {// Separator comment breaks alignment group - "module m;\n" - "localparam foo = 1;\n" - "localparam barr = 2;\n" - "// ============\n" - "localparam baaaaz = 1;\n" - "localparam c = 2;\n" - "endmodule\n", - "module m;\n" - " localparam foo = 1;\n" - " localparam barr = 2;\n" - " // ============\n" - " localparam baaaaz = 1;\n" - " localparam c = 2;\n" - "endmodule\n"}, - {// Blank line does NOT break group with kSeparatorComments - "module m;\n" - "localparam foo = 1;\n" - "localparam barr = 2;\n" - "\n" - "localparam baaaaz = 1;\n" - "localparam c = 2;\n" - "endmodule\n", - "module m;\n" - " localparam foo = 1;\n" - " localparam barr = 2;\n" - "\n" - " localparam baaaaz = 1;\n" - " localparam c = 2;\n" - "endmodule\n"}, - }; - FormatStyle style; - style.column_limit = 40; - style.indentation_spaces = 2; - style.wrap_spaces = 4; - style.parameter_declaration_alignment = AlignmentPolicy::kAlign; - style.alignment_group_boundary = AlignmentGroupBoundary::kSeparatorComments; - for (const auto &test_case : kTestCases) { - VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; - std::ostringstream stream; - const auto status = - FormatVerilog(test_case.input, "<filename>", style, stream); - EXPECT_OK(status) << status.message(); - EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; - } -} - -// Verify that class body parameter/localparam declarations are NOT affected -// by --parameter_declaration_alignment for the kFlushLeft, kPreserve, -// and kInferUserIntent policies (kAlign is covered in -// ClassBodyParamNotAffected). -TEST(FormatterEndToEndTest, ClassBodyParamNotAffectedOtherPolicies) { - static constexpr FormatterTestCase kTestCases[] = { - {// kFlushLeft: class body params remain flush-left - "class c;\n" - "parameter int X = 1;\n" - "parameter int YYYY = 2;\n" - "localparam foo = 3;\n" - "localparam barrrr = 4;\n" - "endclass\n", - "class c;\n" - " parameter int X = 1;\n" - " parameter int YYYY = 2;\n" - " localparam foo = 3;\n" - " localparam barrrr = 4;\n" - "endclass\n"}, - {// kPreserve: parameter_declaration_alignment does not apply to class - // bodies; whitespace is normalized by default formatting. - "class c;\n" - "parameter int X = 1;\n" - "parameter int YYYY = 2;\n" - "endclass\n", - "class c;\n" - " parameter int X = 1;\n" - " parameter int YYYY = 2;\n" - "endclass\n"}, - {// kInferUserIntent: class body params infer flush-left - "class c;\n" - "parameter int X = 1;\n" - "parameter int YYYY = 2;\n" - "endclass\n", - "class c;\n" - " parameter int X = 1;\n" - " parameter int YYYY = 2;\n" - "endclass\n"}, - }; - // kFlushLeft - { - FormatStyle style; - style.column_limit = 40; - style.indentation_spaces = 2; - style.wrap_spaces = 4; - style.parameter_declaration_alignment = AlignmentPolicy::kFlushLeft; - const auto &tc = kTestCases[0]; - std::ostringstream stream; - const auto status = FormatVerilog(tc.input, "<filename>", style, stream); - EXPECT_OK(status) << status.message(); - EXPECT_EQ(stream.str(), tc.expected) << "code:\n" << tc.input; - } - // kPreserve - { - FormatStyle style; - style.column_limit = 40; - style.indentation_spaces = 2; - style.wrap_spaces = 4; - style.parameter_declaration_alignment = AlignmentPolicy::kPreserve; - const auto &tc = kTestCases[1]; - std::ostringstream stream; - const auto status = FormatVerilog(tc.input, "<filename>", style, stream); - EXPECT_OK(status) << status.message(); - EXPECT_EQ(stream.str(), tc.expected) << "code:\n" << tc.input; - } - // kInferUserIntent - { - FormatStyle style; - style.column_limit = 40; - style.indentation_spaces = 2; - style.wrap_spaces = 4; - style.parameter_declaration_alignment = AlignmentPolicy::kInferUserIntent; - const auto &tc = kTestCases[2]; - std::ostringstream stream; - const auto status = FormatVerilog(tc.input, "<filename>", style, stream); - EXPECT_OK(status) << status.message(); - EXPECT_EQ(stream.str(), tc.expected) << "code:\n" << tc.input; - } -} - -// Verify formal_parameters_alignment and parameter_declaration_alignment -// independence for kPreserve and kInferUserIntent combinations. -TEST(FormatterEndToEndTest, - FormalAndBodyParamAlignmentIndependenceOtherPolicies) { - static constexpr FormatterTestCase kTestCases[] = { - {// formal kPreserve + body kAlign: only body params aligned - "module m #(\n" - "int W = 2,\n" - "int LLLL = 4\n" - ");\n" - "localparam foo = 0;\n" - "localparam barrrr = 0;\n" - "endmodule\n", - "module m #(\n" - " int W = 2,\n" - " int LLLL = 4\n" - ");\n" - " localparam foo = 0;\n" - " localparam barrrr = 0;\n" - "endmodule\n"}, - {// formal kAlign + body kPreserve: only formal params aligned - "module m #(\n" - "int W = 2,\n" - "int LLLL = 4\n" - ");\n" - "localparam foo = 0;\n" - "localparam barrrr = 0;\n" - "endmodule\n", - "module m #(\n" - " int W = 2,\n" - " int LLLL = 4\n" - ");\n" - " localparam foo = 0;\n" - " localparam barrrr = 0;\n" - "endmodule\n"}, - {// formal kInferUserIntent + body kAlign: only body params aligned - "module m #(\n" - "int W = 2,\n" - "int LLLL = 4\n" - ");\n" - "localparam foo = 0;\n" - "localparam barrrr = 0;\n" - "endmodule\n", - "module m #(\n" - " int W = 2,\n" - " int LLLL = 4\n" - ");\n" - " localparam foo = 0;\n" - " localparam barrrr = 0;\n" - "endmodule\n"}, - }; - // formal kPreserve + body kAlign - { - FormatStyle style; - style.column_limit = 40; - style.indentation_spaces = 2; - style.wrap_spaces = 4; - style.parameter_declaration_alignment = AlignmentPolicy::kAlign; - style.formal_parameters_alignment = AlignmentPolicy::kPreserve; - const auto &tc = kTestCases[0]; - std::ostringstream stream; - const auto status = FormatVerilog(tc.input, "<filename>", style, stream); - EXPECT_OK(status) << status.message(); - EXPECT_EQ(stream.str(), tc.expected) << "code:\n" << tc.input; - } - // formal kAlign + body kPreserve - { - FormatStyle style; - style.column_limit = 40; - style.indentation_spaces = 2; - style.wrap_spaces = 4; - style.parameter_declaration_alignment = AlignmentPolicy::kPreserve; - style.formal_parameters_alignment = AlignmentPolicy::kAlign; - const auto &tc = kTestCases[1]; - std::ostringstream stream; - const auto status = FormatVerilog(tc.input, "<filename>", style, stream); - EXPECT_OK(status) << status.message(); - EXPECT_EQ(stream.str(), tc.expected) << "code:\n" << tc.input; - } - // formal kInferUserIntent + body kAlign - { - FormatStyle style; - style.column_limit = 40; - style.indentation_spaces = 2; - style.wrap_spaces = 4; - style.parameter_declaration_alignment = AlignmentPolicy::kAlign; - style.formal_parameters_alignment = AlignmentPolicy::kInferUserIntent; - const auto &tc = kTestCases[2]; - std::ostringstream stream; - const auto status = FormatVerilog(tc.input, "<filename>", style, stream); - EXPECT_OK(status) << status.message(); - EXPECT_EQ(stream.str(), tc.expected) << "code:\n" << tc.input; - } -} - -// Verify parameter declarations with string, real, and function-call default -// value types to exercise the ColumnSchemaScanner on non-standard type tokens. -TEST(FormatterEndToEndTest, ParamDeclarationAlignmentTypeVariants) { - static constexpr FormatterTestCase kTestCases[] = { - {// parameter real type - "module m;\n" - "parameter real X = 1.0;\n" - "parameter real Y_LONG = 2.0;\n" - "endmodule\n", - "module m;\n" - " parameter real X = 1.0;\n" - " parameter real Y_LONG = 2.0;\n" - "endmodule\n"}, - {// parameter string type - "module m;\n" - "parameter string s = \"hello\";\n" - "parameter string long_s = \"world\";\n" - "endmodule\n", - "module m;\n" - " parameter string s = \"hello\";\n" - " parameter string long_s = \"world\";\n" - "endmodule\n"}, - {// parameter with function call in default value - "module m;\n" - "parameter int W = func(1, 2);\n" - "parameter int H_LONG = other(3);\n" - "endmodule\n", - "module m;\n" - " parameter int W = func(1, 2);\n" - " parameter int H_LONG = other(3);\n" - "endmodule\n"}, - }; - FormatStyle style; - style.column_limit = 40; - style.indentation_spaces = 2; - style.wrap_spaces = 4; - style.parameter_declaration_alignment = AlignmentPolicy::kAlign; - for (const auto &test_case : kTestCases) { - VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; - std::ostringstream stream; - const auto status = - FormatVerilog(test_case.input, "<filename>", style, stream); - EXPECT_OK(status) << status.message(); - EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; - } -} - -// Verify parameter_declaration_alignment kInferUserIntent in package bodies. -TEST(FormatterEndToEndTest, ParamDeclarationAlignmentPackageInfer) { - static constexpr FormatterTestCase kTestCases[] = { - {// flush-left params with small diff: infer aligns - "package p;\n" - "localparam foo = 1;\n" - "localparam barr = 2;\n" - "endpackage\n", - "package p;\n" - " localparam foo = 1;\n" - " localparam barr = 2;\n" - "endpackage\n"}, - {// pre-aligned params: infer preserves - "package p;\n" - "localparam foo = 1;\n" - "localparam barr = 2;\n" - "localparam baaaaz = 3;\n" - "endpackage\n", - "package p;\n" - " localparam foo = 1;\n" - " localparam barr = 2;\n" - " localparam baaaaz = 3;\n" - "endpackage\n"}, - }; - FormatStyle style; - style.column_limit = 40; - style.indentation_spaces = 2; - style.wrap_spaces = 4; - style.parameter_declaration_alignment = AlignmentPolicy::kInferUserIntent; - for (const auto &test_case : kTestCases) { - VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; - std::ostringstream stream; - const auto status = - FormatVerilog(test_case.input, "<filename>", style, stream); - EXPECT_OK(status) << status.message(); - EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; - } -} - -// Verify parameter_declaration_alignment boundary behavior in package bodies. -TEST(FormatterEndToEndTest, ParamDeclarationAlignmentPackageBoundary) { - static constexpr FormatterTestCase kTestCases[] = { - {// blank line breaks alignment group in package - "package p;\n" - "localparam foo = 1;\n" - "localparam barr = 2;\n" - "\n" - "localparam baaaaz = 1;\n" - "localparam c = 2;\n" - "endpackage\n", - "package p;\n" - " localparam foo = 1;\n" - " localparam barr = 2;\n" - "\n" - " localparam baaaaz = 1;\n" - " localparam c = 2;\n" - "endpackage\n"}, - {// separator comment breaks alignment group in package - "package p;\n" - "localparam foo = 1;\n" - "localparam barr = 2;\n" - "// ============\n" - "localparam baaaaz = 1;\n" - "localparam c = 2;\n" - "endpackage\n", - "package p;\n" - " localparam foo = 1;\n" - " localparam barr = 2;\n" - " // ============\n" - " localparam baaaaz = 1;\n" - " localparam c = 2;\n" - "endpackage\n"}, - }; - FormatStyle style; - style.column_limit = 40; - style.indentation_spaces = 2; - style.wrap_spaces = 4; - style.parameter_declaration_alignment = AlignmentPolicy::kAlign; - style.alignment_group_boundary = - AlignmentGroupBoundary::kBlankLinesAndSeparatorComments; - for (const auto &test_case : kTestCases) { - VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; - std::ostringstream stream; - const auto status = - FormatVerilog(test_case.input, "<filename>", style, stream); - EXPECT_OK(status) << status.message(); - EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; - } -} - -// Verify the most common default scenario: both formal_parameters_alignment -// and parameter_declaration_alignment set to kInferUserIntent. -TEST(FormatterEndToEndTest, BothParamAlignmentsInferUserIntent) { - static constexpr FormatterTestCase kTestCases[] = { - {// both flush-left with small diff: infer aligns both formal and body - "module m #(\n" - "int W = 2,\n" - "int LL = 4\n" - ");\n" - "localparam foo = 0;\n" - "localparam barr = 0;\n" - "endmodule\n", - "module m #(\n" - " int W = 2,\n" - " int LL = 4\n" - ");\n" - " localparam foo = 0;\n" - " localparam barr = 0;\n" - "endmodule\n"}, - {// both infer: pre-aligned formal, pre-aligned body preserved - "module m #(\n" - "int W = 2,\n" - "int LLLL = 4\n" - ");\n" - "localparam foo = 0;\n" - "localparam barrrr = 0;\n" - "endmodule\n", - "module m #(\n" - " int W = 2,\n" - " int LLLL = 4\n" - ");\n" - " localparam foo = 0;\n" - " localparam barrrr = 0;\n" - "endmodule\n"}, - }; - FormatStyle style; - style.column_limit = 40; - style.indentation_spaces = 2; - style.wrap_spaces = 4; - style.parameter_declaration_alignment = AlignmentPolicy::kInferUserIntent; - style.formal_parameters_alignment = AlignmentPolicy::kInferUserIntent; - for (const auto &test_case : kTestCases) { - VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; - std::ostringstream stream; - const auto status = - FormatVerilog(test_case.input, "<filename>", style, stream); - EXPECT_OK(status) << status.message(); - EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; - } -} - -// Verify that a large multi-line comment block between parameter -// declarations does not crash the formatter. The tree-unwrapper may -// produce a partition structure where the comment tokens are absorbed -// into the following parameter partition, which the alignment code -// must handle gracefully by skipping alignment for that row. -TEST(FormatterEndToEndTest, ParamDeclarationAlignmentCommentBlockNoCrash) { - // These inputs contain large multi-line comment blocks between - // parameter/localparam declarations. The formatter must not crash - // (SIGABRT). Output correctness is secondary; the formatter may - // fall back to preserving the original input when the partition - // structure prevents safe alignment. - const char *kInputs[] = { - "module m;\n" - "parameter int W = 8;\n" - "// Multi-line comment block\n" - "// that spans across\n" - "//\n" - "// several lines\n" - "// of explanatory text\n" - "//\n" - "// It contains enough\n" - "// lines to trigger\n" - "// the partition structure\n" - "// edge case where\n" - "// comment tokens are\n" - "// absorbed into the\n" - "// following parameter\n" - "// partition.\n" - "//\n" - "localparam int H = 2;\n" - "endmodule\n", - "package p;\n" - "parameter int X = 1;\n" - "// Long comment block\n" - "// with many lines\n" - "//\n" - "// of text\n" - "//\n" - "localparam int Y = 2;\n" - "endpackage\n", - }; - FormatStyle style; - style.column_limit = 40; - style.indentation_spaces = 2; - style.wrap_spaces = 4; - style.parameter_declaration_alignment = AlignmentPolicy::kAlign; - for (const char *input : kInputs) { - VLOG(1) << "code-to-format:\n" << input << "<EOF>"; - std::ostringstream stream; - const auto status = FormatVerilog(input, "<filename>", style, stream); - // The primary requirement is that the formatter does not crash - // (SIGABRT). Gtest will report failure if the process aborts. - // The partition structure may cause output format differences; - // the important thing is the formatter handled it gracefully. - } +TEST(FormatterEndToEndTest, SmokeFormatterTestCases) { + RunFormatterTestCases40(kSmokeFormatterTestCases); } // Regression for https://github.com/chipsalliance/verible/issues/2352:
diff --git a/verible/verilog/formatting/formatter_wrap_style_test.cc b/verible/verilog/formatting/formatter_wrap_style_test.cc new file mode 100644 index 0000000..b61fe42 --- /dev/null +++ b/verible/verilog/formatting/formatter_wrap_style_test.cc
@@ -0,0 +1,3405 @@ +// Copyright 2017-2026 The Verible Authors. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Test cases in this file should be *insensitive* to wrapping penalties. +// Penalty-sensitive tests belong in formatter-tuning_test.cc. + +#include <cctype> +#include <cstddef> +#include <sstream> +#include <string> +#include <string_view> +#include <vector> + +#include "absl/status/status.h" +#include "absl/strings/match.h" +#include "absl/strings/str_split.h" +#include "gmock/gmock.h" +#include "gtest/gtest.h" +#include "verible/common/formatting/align.h" +#include "verible/common/formatting/basic-format-style.h" +#include "verible/common/strings/display-utils.h" +#include "verible/common/strings/position.h" +#include "verible/common/util/interval.h" +#include "verible/common/util/logging.h" +#include "verible/verilog/formatting/format-style.h" +#include "verible/verilog/formatting/formatter-test-utils.h" +#include "verible/verilog/formatting/formatter.h" + +namespace verilog { +namespace formatter { +namespace { + +using absl::StatusCode; +using testing::HasSubstr; +using verible::AlignmentPolicy; +using verible::IndentationStyle; +using verible::LineNumberSet; + +// Empty LineNumberSet means format all lines. +static const LineNumberSet kEnableAllLines; + +// Small case set for diagnostic/control-path tests that previously iterated +// the monolithic kFormatterTestCases table. +static constexpr FormatterTestCase kDiagnosticFormatterTestCases[] = { + {"", ""}, + {"\n", "\n"}, + {"module m;wire w;endmodule\n", + "module m;\n" + " wire w;\n" + "endmodule\n"}, + {"class cc ;\n" + "endclass:cc\n", + "class cc;\n" + "endclass : cc\n"}, +}; + +TEST(FormatterEndToEndTest, AutoInferAlignment) { + static constexpr FormatterTestCase kTestCases[] = { + {"", ""}, + {"\n", "\n"}, + {"class cc ;\n" + "endclass:cc\n", + "class cc;\n" + "endclass : cc\n"}, + + // module port declarations + {"module pd(\n" + "input wire foo,\n" + "output reg bar\n" + ");\n" + "endmodule:pd\n", + "module pd (\n" + " input wire foo,\n" // flush-left vs. align are similar enough, + " output reg bar\n" // so automatic policy will align. + ");\n" + "endmodule : pd\n"}, + {"module pd(\n" + "input foo_pkg::baz_t foo,\n" + "output reg bar\n" + ");\n" + "endmodule:pd\n", + "module pd (\n" + " input foo_pkg::baz_t foo,\n" // alignment would add too many spaces + " output reg bar\n" // so infer intent to flush-left. + ");\n" + "endmodule : pd\n"}, + {"module pd(\n" + "input foo_pkg::baz_t foo,\n" + "output reg bar\n" // user injects 4 excess spaces here ... + ");\n" + "endmodule:pd\n", + "module pd (\n" + " input foo_pkg::baz_t foo,\n" + " output reg bar\n" // ... and triggers alignment. + ");\n" + "endmodule : pd\n"}, + {"module pd(\n" + "`ifdef FAA\n" // inside preprocessing conditional + "input baaaz_t foo,\n" + "output reg bar\n" // user injects 4 excess spaces here ... + "`endif\n" + ");\n" + "endmodule:pd\n", + "module pd (\n" + "`ifdef FAA\n" + " input baaaz_t foo,\n" + " output reg bar\n" // ... and triggers alignment. + "`endif\n" + ");\n" + "endmodule : pd\n"}, + {"module pd(\n" + "`ifdef FAA\n" // inside preprocessing conditional + "input baaaz_t foo,\n" + "`else\n" + "output reg bar\n" // user injects 4 excess spaces here ... + "`endif\n" + ");\n" + "endmodule:pd\n", + "module pd (\n" + "`ifdef FAA\n" + " input baaaz_t foo,\n" // aligned + "`else\n" // aligned across preprocessing directives + " output reg bar\n" // ... and triggers alignment. + "`endif\n" + ");\n" + "endmodule : pd\n"}, + {"module pd(\n" + "input logic [31:0] bus,\n" + "input logic [7:0] bus2,\n" + "`ifdef FAA\n" // inside preprocessing conditional + "input baaaz_t foo,\n" + "`else\n" + "output reg bar,\n" // user injects 4 excess spaces here ... + "`endif\n" + "output out_t zout1,\n" + "output out_t zout2\n" + ");\n" + "endmodule:pd\n", + "module pd (\n" + " input logic [31:0] bus,\n" // treated as one large group + " input logic [ 7:0] bus2,\n" + "`ifdef FAA\n" + " input baaaz_t foo,\n" // aligned + "`else\n" // aligned across preprocessing directives + " output reg bar,\n" // ... and triggers alignment. + "`endif\n" + " output out_t zout1,\n" + " output out_t zout2\n" + ");\n" + "endmodule : pd\n"}, + {"module pd(\n" + "input logic [7:0] bus2,\n" + "`ifndef FAA\n" // inside preprocessing conditional + "input logic [31:0] bus,\n" + "input baaaz_t foo,\n" + "`elsif BLA\n" + "output reg bar,\n" // user injects 4 excess spaces here ... + "output out_t zout1,\n" + "`endif\n" + "output out_t zout2\n" + ");\n" + "endmodule:pd\n", + "module pd (\n" + " input logic [ 7:0] bus2,\n" + "`ifndef FAA\n" + " input logic [31:0] bus,\n" // treated as one large group + " input baaaz_t foo,\n" // aligned + "`elsif BLA\n" // aligned across preprocessing directives + " output reg bar,\n" // ... and triggers alignment. + " output out_t zout1,\n" + "`endif\n" + " output out_t zout2\n" + ");\n" + "endmodule : pd\n"}, + {// data declaration and net declaration in ports + "module m(\n" + "logic [x:y]a ,\n" // packed dimensions, induce alignment + "wire [pp:qq] [e:f]b\n" // packed dimensions, 2D + ") ;\n" + "endmodule\n", + "module m (\n" + " logic [ x:y] a,\n" + " wire [pp:qq][e:f] b\n" + ");\n" + "endmodule\n"}, + {// used-defined data declarations in ports + "module m(\n" + "a::bb [x:y]a ,\n" // packed dimensions, induce alignment + "c#(d,e) [pp:qq] [e:f]b\n" // packed dimensions, 2D + ") ;\n" + "endmodule\n", + "module m (\n" + " a::bb [ x:y] a,\n" + " c#(d, e) [pp:qq][e:f] b\n" + ");\n" + "endmodule\n"}, + + // named parameter arguments + {"module mm ;\n" + "foo #(\n" + ".a(a),\n" + ".bb(bb)\n" + ")bar( );\n" + "endmodule:mm\n", + "module mm;\n" + " foo #(\n" + " .a (a),\n" // align doesn't add too many spaces, so align + " .bb(bb)\n" + " ) bar ();\n" + "endmodule : mm\n"}, + {"module mm ;\n" + "foo #(\n" + ".a(a),\n" + ".bbcccc(bb)\n" + ")bar( );\n" + "endmodule:mm\n", + "module mm;\n" + " foo #(\n" + " .a(a),\n" // align would add too many spaces, so flush-left + " .bbcccc(bb)\n" + " ) bar ();\n" + "endmodule : mm\n"}, + {"module mm ;\n" + "foo #(\n" + ".a(a ),\n" // user manually triggers alignment with excess spaces + ".bbcccc(bb)\n" + ")bar( );\n" + "endmodule:mm\n", + "module mm;\n" + " foo #(\n" + " .a (a),\n" // induced alignment + " .bbcccc(bb)\n" + " ) bar ();\n" + "endmodule : mm\n"}, + {"module mm ;\n" + "foo #(\n" + "//c1\n" // with comments (indented but not aligned) + ".a(a ),\n" // user manually triggers alignment with excess spaces + "//c2\n" + ".bbcccc(bb)\n" + "//c3\n" + ")bar( );\n" + "endmodule:mm\n", + "module mm;\n" + " foo #(\n" + " //c1\n" + " .a (a),\n" // induced alignment + " //c2\n" + " .bbcccc(bb)\n" + " //c3\n" + " ) bar ();\n" + "endmodule : mm\n"}, + {"module mm ;\n" + "foo #(\n" + ".a( (1 +2)),\n" // excess spaces, testing extra parentheses + ".bbcccc((c*d)+(e*f))\n" + ")bar( );\n" + "endmodule:mm\n", + "module mm;\n" + " foo #(\n" + " .a ((1 + 2)),\n" // induced alignment + " .bbcccc((c * d) + (e * f))\n" + " ) bar ();\n" + "endmodule : mm\n"}, + + // named port connections + {"module mm ;\n" + "foo bar(\n" + ".a(a),\n" + ".bb(bb)\n" + ");\n" + "endmodule:mm\n", + "module mm;\n" + " foo bar (\n" + " .a (a),\n" // align doesn't add too many spaces, so align + " .bb(bb)\n" + " );\n" + "endmodule : mm\n"}, + {"module mm ;\n" + "foo bar(\n" + ".a(a),\n" + ".bbbbbb(bb)\n" + ");\n" + "endmodule:mm\n", + "module mm;\n" + " foo bar (\n" + " .a(a),\n" // align would add too many spaces, so flush-left + " .bbbbbb(bb)\n" + " );\n" + "endmodule : mm\n"}, + {"module mm ;\n" + "foo bar(\n" + ".a (a),\n" // user manually triggers alignment with excess spaces + ".bbbbbb(bb)\n" + ");\n" + "endmodule:mm\n", + "module mm;\n" + " foo bar (\n" + " .a (a),\n" // alignment fixed + " .bbbbbb(bb)\n" + " );\n" + "endmodule : mm\n"}, + + // net variable declarations + {"module nn;\n" + "wire wwwww;\n" + "logic lll;\n" + "endmodule : nn\n", + "module nn;\n" + " wire wwwww;\n" // alignment adds few spaces, so align + " logic lll;\n" + "endmodule : nn\n"}, + {"module nn;\n" + "wire wwwww;\n" + "foo_pkg::baz_t lll;\n" + "endmodule : nn\n", + "module nn;\n" + " wire wwwww;\n" // alignment adds too many spaces, so flush-left + " foo_pkg::baz_t lll;\n" + "endmodule : nn\n"}, + {"module nn;\n" + "wire wwwww;\n" // user injects spaces to trigger alignment + "foo_pkg::baz_t lll;\n" + "endmodule : nn\n", + "module nn;\n" + " wire wwwww;\n" // ... and gets alignment + " foo_pkg::baz_t lll;\n" + "endmodule : nn\n"}, + {// data/net declarations as generate items (conditional) + "module nn;\n" + "if (cc)begin:fff\n" + "wire wwwww;\n" + "logic lll;\n" + "end:fff\n" + "endmodule : nn\n", + "module nn;\n" + " if (cc) begin : fff\n" + " wire wwwww;\n" // alignment adds few spaces, so align + " logic lll;\n" + " end : fff\n" + "endmodule : nn\n"}, + + // continuous assignments + {"module m_assign;\n" + "assign foo = 1'b1;\n" // alignment adds few spaces, so align + "assign baar = 1'b0;\n" + "endmodule\n", + "module m_assign;\n" + " assign foo = 1'b1;\n" // aligned + " assign baar = 1'b0;\n" + "endmodule\n"}, + {"module m_assign;\n" + "assign foo = 1'b1;\n" // alignment adds too many spaces, so + // flush-left + "assign baaaaaar = 1'b0;\n" + "endmodule\n", + "module m_assign;\n" + " assign foo = 1'b1;\n" // flush-left + " assign baaaaaar = 1'b0;\n" + "endmodule\n"}, + {"module m_assign;\n" + "assign foo = 1'b1;\n" // induce alignment with excess spaces + "assign baaaaaar = 1'b0;\n" + "endmodule\n", + "module m_assign;\n" + " assign foo = 1'b1;\n" // aligned + " assign baaaaaar = 1'b0;\n" + "endmodule\n"}, + {// currently, does not assign across ifdefs + "module m_assign;\n" + "`ifdef FOO\n" + "assign foo = 1'b1;\n" // induce alignment with excess spaces + "assign baaaaaar = 1'b0;\n" + "`else\n" + "assign zooo = 2'b11;\n" + "assign yoo = 2'b00;\n" + "`endif\n" + "endmodule\n", + "module m_assign;\n" + "`ifdef FOO\n" + " assign foo = 1'b1;\n" // aligned + " assign baaaaaar = 1'b0;\n" + "`else\n" // aligned separately above/below + " assign zooo = 2'b11;\n" // aligned + " assign yoo = 2'b00;\n" // aligned + "`endif\n" + "endmodule\n"}, + {// mixed net declaration and continuous assignment, both groups aligned + "module m_assign;\n" + "wire wwwww;\n" // induce alignment + "foo_pkg::baz_t lll;\n" + "assign foo = 1'b1;\n" // induce alignment + "assign baaaaaar = 1'b0;\n" + "endmodule\n", + "module m_assign;\n" + " wire wwwww;\n" // aligned + " foo_pkg::baz_t lll;\n" + " assign foo = 1'b1;\n" // aligned + " assign baaaaaar = 1'b0;\n" + "endmodule\n"}, + {// continuous assignments as generate items (conditional) + "module m_assign;\n" + "if (xy) begin\n" + "assign foo = 1'b0;\n" // align: adds few spaces + "assign baaar = 1'b1;\n" + "end else begin\n" + "assign goo = 1'b1;\n" // induce alignment with excess spaces + "assign zaaaaaar = 1'b0;\n" + "end\n" + "endmodule\n", + "module m_assign;\n" + " if (xy) begin\n" + " assign foo = 1'b0;\n" // aligned + " assign baaar = 1'b1;\n" + " end else begin\n" + " assign goo = 1'b1;\n" // induce alignment with excess spaces + " assign zaaaaaar = 1'b0;\n" + " end\n" + "endmodule\n"}, + {// continuous assignments as generate items (loop) + "module m_assign;\n" + "for(genvar i=0; i<k; ++i ) begin\n" + "assign foo = 1'b0;\n" // align: adds few spaces + "assign baaar = 1'b1;\n" + "end\n" + "endmodule\n", + "module m_assign;\n" + " for (genvar i = 0; i < k; ++i) begin\n" + " assign foo = 1'b0;\n" // aligned + " assign baaar = 1'b1;\n" + " end\n" + "endmodule\n"}, + {// continuous assignments as generate items (case) + "module m_assign;\n" + "case (c)\n" + "jk:begin\n" + "assign foo = 1'b0;\n" // align: adds few spaces + "assign baaar = 1'b1;\n" + "end\n" + "endcase\n" + "endmodule\n", + "module m_assign;\n" + " case (c)\n" + " jk: begin\n" + " assign foo = 1'b0;\n" // aligned + " assign baaar = 1'b1;\n" + " end\n" + " endcase\n" + "endmodule\n"}, + {// continuous assignment with comment + "module m;\n" + "// comment1\n" + "assign aaaaa = (bbbbb != ccccc) &\n" + "// comment2\n" + "(ddddd | (eeeee & ffffff));\n" + "endmodule\n", + "module m;\n" + " // comment1\n" + " assign aaaaa = (bbbbb != ccccc) &\n" + " // comment2\n" + " (ddddd | (eeeee & ffffff));\n" + "endmodule\n"}, + + // net/variable assignments: blocking and nonblocking + {"module ma ;\n" + "initial begin\n" + "aa = b;\n" + "c = 1'b0;\n" + "end\n" + "endmodule\n", + "module ma;\n" + " initial begin\n" + " aa = b;\n" + " c = 1'b0;\n" // only one space to align + " end\n" + "endmodule\n"}, + {"function void fa ;\n" + "c = 1'b0;\n" + "aa = b;\n" + "endfunction\n", + "function void fa;\n" + " c = 1'b0;\n" // only one space to align + " aa = b;\n" + "endfunction\n"}, + {"task ta ; \n" + "aa = b;\n" + "c = 1'b0;\n" + "endtask\n", + "task ta;\n" + " aa = b;\n" + " c = 1'b0;\n" // only one space to align + "endtask\n"}, + {"module ma ;\n" + "always@( posedge clk) begin\n" + "aaa <= b;\n" + "c <= 1'b0;\n" + "end\n" + "endmodule\n", + "module ma;\n" + " always @(posedge clk) begin\n" + " aaa <= b;\n" + " c <= 1'b0;\n" // only two spaces to align + " end\n" + "endmodule\n"}, + {"function int fa ;\n" + "c <= 1'b0;\n" + "aa <= b;\n" + "return 0 ;\n" + "endfunction\n", + "function int fa;\n" + " c <= 1'b0;\n" // only one space to align + " aa <= b;\n" + " return 0;\n" + "endfunction\n"}, + {"task ta ; \n" + "$display (\"hello\" );\n" + "aa <= b;\n" + "c <= 1'b0;\n" + "endtask\n", + "task ta;\n" + " $display(\"hello\");\n" + " aa <= b;\n" + " c <= 1'b0;\n" // only one space to align + "endtask\n"}, + {// mixed blocking and nonblocking assignments + "module ma ;\n" + "always@( posedge clk) begin\n" + "aaaaa = b;\n" + "ccc = 1'b0;\n" + "aaa <= b;\n" + "c <= 1'b0;\n" + "end\n" + "endmodule\n", + "module ma;\n" + " always @(posedge clk) begin\n" + " aaaaa = b;\n" + " ccc = 1'b0;\n" // only two spaces to align + " aaa <= b;\n" + " c <= 1'b0;\n" // only two spaces to align (separate group) + " end\n" + "endmodule\n"}, + {"task ta ; \n" + "aa <= b;\n" + "c <= 1'b0;\n" + "$display (\"hello\" );\n" // separates above/below alignment groups + "zzaa <= b;\n" + "zzc <= 1'b0;\n" + "endtask\n", + "task ta;\n" + " aa <= b;\n" + " c <= 1'b0;\n" // only one space to align + " $display(\"hello\");\n" + " zzaa <= b;\n" + " zzc <= 1'b0;\n" // only one space to align + "endtask\n"}, + {"task ta ; \n" + "$display (\"hello\" );\n" + "aaaaa <= b;\n" + "c <= 1'b0;\n" // need too many spaces to align + "endtask\n", + "task ta;\n" + " $display(\"hello\");\n" + " aaaaa <= b;\n" + " c <= 1'b0;\n" // so keep flush-left + "endtask\n"}, + {"function void fa ; \n" + "$display (\"hello\" );\n" + "aaaaa = b;\n" + "c = 1'b0;\n" // need too many spaces to align + "endfunction\n", + "function void fa;\n" + " $display(\"hello\");\n" + " aaaaa = b;\n" + " c = 1'b0;\n" // so keep flush-left + "endfunction\n"}, + {"module ma ;\n" + "always@( posedge clk) begin\n" + "aaaxx <= b;\n" + "c <= 1'b0;\n" // need too many spaces to align + "end\n" + "endmodule\n", + "module ma;\n" + " always @(posedge clk) begin\n" + " aaaxx <= b;\n" + " c <= 1'b0;\n" // so keep flush-left + " end\n" + "endmodule\n"}, + {"module ma ;\n" + "always@( posedge clk) begin\n" + "aaaxx <= b ;\n" // inject 4 spaces to induce alignment + "c <= 1'b0;\n" + "end\n" + "endmodule\n", + "module ma;\n" + " always @(posedge clk) begin\n" + " aaaxx <= b;\n" + " c <= 1'b0;\n" // induced alignment + " end\n" + "endmodule\n"}, + {"module ma ;\n" + "always@( posedge clk) begin\n" + "aaaxx <= b ;\n" // inject 4 spaces to induce alignment + "//comment\n" + "c <= 1'b0;\n" + "end\n" + "endmodule\n", + "module ma;\n" + " always @(posedge clk) begin\n" + " aaaxx <= b;\n" + " //comment\n" // ignored within alignment group + " c <= 1'b0;\n" // induced alignment + " end\n" + "endmodule\n"}, + + // local variable declarations as statements + {"task tt ;\n" + "int foo;\n" // only 2 spaces needed to align + "bar_t baz;\n" + "endtask\n", + "task tt;\n" + " int foo;\n" // aligned + " bar_t baz;\n" + "endtask\n"}, + {"function ff ;\n" + "bar_t baz;\n" + "int foo;\n" // only 2 spaces needed to align + "endfunction\n", + "function ff;\n" + " bar_t baz;\n" + " int foo;\n" // aligned + "endfunction\n"}, + {"task tt ;\n" + "int foo;\n" // too many spaces needed to align + "baaaar_t baz;\n" + "endtask\n", + "task tt;\n" + " int foo;\n" // so flush-left + " baaaar_t baz;\n" + "endtask\n"}, + {"function ff ;\n" + "baaaar_t baz;\n" + "int foo;\n" // too many spaces needed to align + "endfunction\n", + "function ff;\n" + " baaaar_t baz;\n" + " int foo;\n" // so flush-left + "endfunction\n"}, + {"task tt ;\n" + "int foo;\n" // injected spaces to induce alignment + "baaaar_t baz;\n" + "endtask\n", + "task tt;\n" + " int foo;\n" // aligned + " baaaar_t baz;\n" + "endtask\n"}, + {"function ff ;\n" + "baaaar_t baz ;\n" // injected spaces to induce alignment + "int foo;\n" + "endfunction\n", + "function ff;\n" + " baaaar_t baz;\n" + " int foo;\n" // so aligned + "endfunction\n"}, + + // formal parameters + {"module pp #(\n" + "int W,\n" + "type T\n" + ") ();\n" + "endmodule : pp\n", + "module pp #(\n" + " int W,\n" // alignment adds few spaces, so do it + " type T\n" + ") ();\n" + "endmodule : pp\n"}, + {"module pp #(\n" + "int W,\n" + "int[xx:yy] T\n" + ") ();\n" + "endmodule : pp\n", + "module pp #(\n" + " int W,\n" // alignment adds many spaces, so flush-left + " int [xx:yy] T\n" + ") ();\n" + "endmodule : pp\n"}, + {"module pp #(\n" + "int W,\n" + "int[xx:yy] T\n" // user injected spaces intentionally + ") ();\n" + "endmodule : pp\n", + "module pp #(\n" + " int W,\n" // ... trigger alignment + " int [xx:yy] T\n" + ") ();\n" + "endmodule : pp\n"}, + + // class member variables + {"class cc ;\n" + "int my_int;\n" + "bar_t my_bar;\n" + "endclass:cc\n", + "class cc;\n" + " int my_int;\n" // align doesn't add too many spaces, so align + " bar_t my_bar;\n" + "endclass : cc\n"}, + {"class cc ;\n" + "int my_int;\n" + "foo_pkg::bar_t my_bar;\n" + "endclass:cc\n", + "class cc;\n" + " int my_int;\n" // align would add too many spaces, so flush-left + " foo_pkg::bar_t my_bar;\n" + "endclass : cc\n"}, + {"class cc ;\n" + "int my_int;\n" // intentional excessive spaces, trigger alignment + "foo_pkg::bar_t my_bar;\n" + "endclass:cc\n", + "class cc;\n" + " int my_int;\n" + " foo_pkg::bar_t my_bar;\n" + "endclass : cc\n"}, + {"class cc ;\n" + "int my_int;\n" // unable to infer user's intent, so preserve + "foo_pkg::bar_t my_bar;\n" + "endclass:cc\n", + "class cc;\n" + " int my_int;\n" // ... but still indent + " foo_pkg::bar_t my_bar;\n" + "endclass : cc\n"}, + + // case item test cases + {// small difference between flush-left and align, so align + "function f; case (x)kZZZZ :if( b )break; default :return 2;" + "endcase endfunction\n", + "function f;\n" + " case (x)\n" + " kZZZZ: if (b) break;\n" // aligned, only adds 2 spaces + " default: return 2;\n" + " endcase\n" + "endfunction\n"}, + {// small error relative to flush-left, so flush-left + "function f; case (x)kZ :if( b )break; default :return 2;" + "endcase endfunction\n", + "function f;\n" + " case (x)\n" + " kZ: if (b) break;\n" // flush-left + " default: return 2;\n" + " endcase\n" + "endfunction\n"}, + {// intentional spacing error (delta=4) induces alignment + "function f; case (x)kZ :if( b )break; default :return 2;" + "endcase endfunction\n", + "function f;\n" + " case (x)\n" + " kZ: if (b) break;\n" + " default: return 2;\n" + " endcase\n" + "endfunction\n"}, + {// induced alignment, with ignored comments + "function f; case (x)kZ :if( b )break; \n//c1\n kXX: g = f; " + "\n//c2\ndefault :return 2;" + "endcase endfunction\n", + "function f;\n" + " case (x)\n" + " kZ: if (b) break;\n" + " //c1\n" + " kXX: g = f;\n" + " //c2\n" + " default: return 2;\n" + " endcase\n" + "endfunction\n"}, + {// induced alignment, ignore multiline case item in the middle + "function f; case (x)" + "kZ :if( b )break; " + "kYY :return 2;" // excess spaces induce alignment + " kXXXXXXXXX: begin end" // multi-line, ignored + " kWWWWW: cc = 23;\n" + " kVVV: cd = 24;\n" + "endcase endfunction\n", + "function f;\n" + " case (x)\n" + " kZ: if (b) break;\n" + " kYY: return 2;\n" + " kXXXXXXXXX: begin\n" // separates above/below groups + " end\n" + " kWWWWW: cc = 23;\n" + " kVVV: cd = 24;\n" // aligned + " endcase\n" + "endfunction\n"}, + {// induced alignment, ignore multiline case item in the middle + "function f; case (x)" + "kZ :if( b )break; " + "kYY :return 2;" // excess spaces induce alignment + " kXXXXXXXXX: if(w)begin end" // multi-line, ignored + " kWWWWW: cc = 23;\n" + " kVVV: cd = 24;\n" + "endcase endfunction\n", + "function f;\n" + " case (x)\n" + " kZ: if (b) break;\n" + " kYY: return 2;\n" + " kXXXXXXXXX:\n" // TODO(fangism): allow this to merge with if() + // else indent the following two lines + " if (w) begin\n" // separates above/below groups + " end\n" + " kWWWWW: cc = 23;\n" + " kVVV: cd = 24;\n" // aligned + " endcase\n" + "endfunction\n"}, + {// induced alignment, ignore multiline case item in the middle + "task t; case (x)" + "kZ :if( b )break; " + "kYY :return 2;" // excess spaces induce alignment + " kXXXXXXXXX: fork join" // multi-line, ignored + " kWWWWW: cc = 23;\n" + " kVVV: cd = 24;\n" + "endcase endtask\n", + "task t;\n" + " case (x)\n" + " kZ: if (b) break;\n" + " kYY: return 2;\n" + " kXXXXXXXXX:\n" // TODO(fangism): allow this to merge with fork + // else indent the following two lines + " fork\n" // separates above/below groups + " join\n" + " kWWWWW: cc = 23;\n" + " kVVV: cd = 24;\n" // aligned + " endcase\n" + "endtask\n"}, + {// case-inside: small difference between flush-left and align, so align + "function f; case (x)inside [0:3] :yy=zzz; [4:11] :yy=zz;" + "endcase endfunction\n", + "function f;\n" + " case (x) inside\n" + " [0 : 3]: yy = zzz;\n" // aligned, only adds 1 spaces + " [4 : 11]: yy = zz;\n" + " endcase\n" + "endfunction\n"}, + {// case-inside: align with comments + "function f; case (x)inside \n//c1\n[0:3] :yy=zzz;\n//c2\n" + " [4:11] :yy=zz;\n//c3\n" + "endcase endfunction\n", + "function f;\n" + " case (x) inside\n" + " //c1\n" + " [0 : 3]: yy = zzz;\n" // aligned, only adds 1 spaces + " //c2\n" + " [4 : 11]: yy = zz;\n" + " //c3\n" + " endcase\n" + "endfunction\n"}, + {// case-inside: flush left + "function f; case (x)inside [0:3] :yy=zzz; [4:999999] :yy=zz;" + "endcase endfunction\n", + "function f;\n" + " case (x) inside\n" + " [0 : 3]: yy = zzz;\n" // flush-left + " [4 : 999999]: yy = zz;\n" + " endcase\n" + "endfunction\n"}, + {// case-inside: induce alignment + "function f; case (x)inside [0:3 ] :yy=zzz; [4:999999] :yy=zz;" + "endcase endfunction\n", + "function f;\n" + " case (x) inside\n" + " [0 : 3]: yy = zzz;\n" // aligned + " [4 : 999999]: yy = zz;\n" + " endcase\n" + "endfunction\n"}, + {// case-generate: align would add few spaces, so align + "module mc ; case (x)kZ : gg h(); kXYY :j kk();" + "endcase endmodule\n", + "module mc;\n" + " case (x)\n" + " kZ: gg h ();\n" // align + " kXYY: j kk ();\n" + " endcase\n" + "endmodule\n"}, + {// case-generate + comment: align would add few spaces, so align + "module mc ; case (x)kZ : gg h(); \n//c1\n kXYY :j kk();" + "endcase endmodule\n", + "module mc;\n" + " case (x)\n" + " kZ: gg h ();\n" // align + " //c1\n" + " kXYY: j kk ();\n" + " endcase\n" + "endmodule\n"}, + {// case-generate: align would add too many space, so flush-left + "module mc ; case (x)kZ : gg h(); kXYYYY :j kk();" + "endcase endmodule\n", + "module mc;\n" + " case (x)\n" + " kZ: gg h ();\n" // flush-left + " kXYYYY: j kk ();\n" + " endcase\n" + "endmodule\n"}, + {// case-generate: inject spaces to induce alignment + "module mc ; case (x)kZ : gg h(); kXYYYY : j kk();" + "endcase endmodule\n", + "module mc;\n" + " case (x)\n" + " kZ: gg h ();\n" // align + " kXYYYY: j kk ();\n" + " endcase\n" + "endmodule\n"}, + {// randcase: align (small difference from flush-left) + "task trc ;randcase 10: x = 1; 1: x = 3; endcase endtask", + "task trc;\n" + " randcase\n" + " 10: x = 1;\n" + " 1: x = 3;\n" // aligned + " endcase\n" + "endtask\n"}, + {// randcase: inferred flush-left + "task trc ;randcase 10000: x = 1; 1: x = 3; endcase endtask", + "task trc;\n" + " randcase\n" + " 10000: x = 1;\n" + " 1: x = 3;\n" + " endcase\n" + "endtask\n"}, + {// randcase: induce alignment + "task trc ;randcase 10000: x = 1 ; 1: x = 3; endcase endtask", + "task trc;\n" + " randcase\n" + " 10000: x = 1;\n" + " 1: x = 3;\n" // aligned + " endcase\n" + "endtask\n"}, + + // distributions + {"class foo;\n" + "constraint c { " + "timer_enable dist {\n" + "8'hfe := 9 , \n" + "12'hfff := 1 }; " + "} endclass\n", + "class foo;\n" + " constraint c {\n" + " timer_enable dist {\n" + " 8'hfe := 9,\n" // only two spaces needed to align + " 12'hfff := 1\n" // so align + " };\n" + " }\n" + "endclass\n"}, + {"class foo;\n" + "constraint c { " + "timer_enable dist {\n" + "[ 8'h0 : 8'hfe ] :/ 9 , \n" + "8'hff :/ 1 }; " // takes many spaces to align this, so... + "} endclass\n", + "class foo;\n" + " constraint c {\n" + " timer_enable dist {\n" + " [8'h0 : 8'hfe] :/ 9,\n" + " 8'hff :/ 1\n" // flush-left + " };\n" + " }\n" + "endclass\n"}, + {"class foo;\n" + "constraint c { " + "timer_enable dist {\n" + "[ 8'h0 : 8'hfe ] :/ 9 , \n" + "8'hff :/ 1 }; " // inject excess spaces to trigger alignment + "} endclass\n", + "class foo;\n" + " constraint c {\n" + " timer_enable dist {\n" + " [8'h0 : 8'hfe] :/ 9,\n" + " 8'hff :/ 1\n" // aligned + " };\n" + " }\n" + "endclass\n"}, + {"class foo;\n" + "constraint c { " + "timer_enable dist {\n" + "//comment1\n" + "[ 8'h0 : 8'hfe ] :/ 9 , \n" + "//comment2\n" + "8'hff :/ 1 \n" + "//comment3\n" + "}; " // inject excess spaces to trigger alignment + "} endclass\n", + "class foo;\n" + " constraint c {\n" + " timer_enable dist {\n" + " //comment1\n" + " [8'h0 : 8'hfe] :/ 9,\n" + " //comment2\n" // align across comment + " 8'hff :/ 1\n" // aligned + " //comment3\n" + " };\n" + " }\n" + "endclass\n"}, + {"module foo ();\n" + " always @(posedge bar) begin\n" + " if (1==1) begin\n" + " ham();\n" + " end else if (2==2) begin\n" + " jam();\n" + " end else begin\n" + " spam();\n" + " end\n" + " end\n" + "endmodule\n", + "module foo ();\n" + " always @(posedge bar) begin\n" + " if (1 == 1) begin\n" + " ham();\n" + " end else if (2 == 2) begin\n" + " jam();\n" + " end else begin\n" + " spam();\n" + " end\n" + " end\n" + "endmodule\n"}, + }; + // Use a fixed style. + FormatStyle style; + style.column_limit = 40; + style.indentation_spaces = 2; + style.wrap_spaces = 4; + // Override some settings to test auto-inferred alignment. + style.ApplyToAllAlignmentPolicies(AlignmentPolicy::kInferUserIntent); + + for (const auto &test_case : kTestCases) { + VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; + std::ostringstream stream; + const auto status = + FormatVerilog(test_case.input, "<filename>", style, stream); + // Require these test cases to be valid. + EXPECT_OK(status) << status.message(); + EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; + } +} // NOLINT(readability/fn_size) + +static constexpr FormatterTestCase kFormatterWideTestCases[] = { + // specify blocks + {"module specify_tests ;\n" + "specify\n" // empty list + "endspecify\n" + "endmodule", + "module specify_tests;\n" + " specify\n" + " endspecify\n" + "endmodule\n"}, + {"module specify_tests ;\n" + "specify\n" + "$recrem (posedge R, posedge C,\n" + "t1, t2);\n" + "endspecify\n" + "endmodule", + "module specify_tests;\n" + " specify\n" + " $recrem(posedge R, posedge C, t1, t2);\n" + " endspecify\n" + "endmodule\n"}, + {"module specify_tests ;\n" + "specify\n" + "// TODO: add this\n" + "endspecify \n" + "endmodule", + "module specify_tests;\n" + " specify\n" + " // TODO: add this\n" + " endspecify\n" + "endmodule\n"}, + {"module specify_tests ;\n" + "specify \n" + " //c1\n" + "$setup ( posedge A, posedge B,\n" + "t1);//c2\n" + " //c3\n" + "$hold ( posedge B , posedge A,t2); //c4\n" + "\t//c5\n" + "endspecify\n" + "endmodule", + "module specify_tests;\n" + " specify\n" + " //c1\n" + " $setup(posedge A, posedge B, t1); //c2\n" + " //c3\n" + " $hold(posedge B, posedge A, t2); //c4\n" + " //c5\n" + " endspecify\n" + "endmodule\n"}, + {"module specify_tests ;\n" + "specify \n" + "$setup ( posedge A, posedge B,\n" + "t1);\n" + "$hold ( posedge B , posedge A,t2);\n" + "endspecify\n" + "endmodule", + "module specify_tests;\n" + " specify\n" + " $setup(posedge A, posedge B, t1);\n" + " $hold(posedge B, posedge A, t2);\n" + " endspecify\n" + "endmodule\n"}, + {"module specify_tests ;\n" + "specify \n" + " `ifdef CCC\n" + "$setup ( posedge A, posedge B,\n" + "t1);\n" + " `else\n" + "$hold ( posedge B , posedge A,t2); \n" + "\t`endif\n" + "endspecify\n" + "endmodule", + "module specify_tests;\n" + " specify\n" + "`ifdef CCC\n" + " $setup(posedge A, posedge B, t1);\n" + "`else\n" + " $hold(posedge B, posedge A, t2);\n" + "`endif\n" + " endspecify\n" + "endmodule\n"}, +}; + +// These tests just need a larger column limit to fit on one line. +TEST(FormatterEndToEndTest, VerilogFormatWideTest) { + // Use a fixed style. + FormatStyle style; + style.column_limit = 60; + style.indentation_spaces = 2; + style.wrap_spaces = 4; + for (const auto &test_case : kFormatterWideTestCases) { + VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; + std::ostringstream stream; + const auto status = + FormatVerilog(test_case.input, "<filename>", style, stream); + // Require these test cases to be valid. + EXPECT_OK(status) << status.message(); + EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; + } +} + +TEST(FormatterEndToEndTest, DisableModulePortDeclarations) { + static constexpr FormatterTestCase kTestCases[] = { + {"", ""}, + {"\n", "\n"}, + {"\n\n", "\n\n"}, + {"module m ;\t\n" + " endmodule\n", + "module m;\n" + "endmodule\n"}, + {"module m( ) ;\n" + " endmodule\n", + "module m ();\n" // empty ports formatted compactly + "endmodule\n"}, + {// for a single port, the alignment handler doesn't even consider it a + // group so it falls back to standard flush-left behavior. + "module m ( input clk )\t;\n" + " endmodule\n", + "module m (\n" + " input clk\n" + ");\n" + "endmodule\n"}, + {// example with two ports + "module m (\n" + "input clk,\n" + "output bar\n" + ")\t;\n" + " endmodule\n", + "module m (\n" + " input clk,\n" // indented, but internal pre-existing spacing + // preserved + " output bar\n" + ");\n" + "endmodule\n"}, + }; + FormatStyle style; + style.column_limit = 40; + style.indentation_spaces = 2; + style.wrap_spaces = 4; + style.port_declarations_alignment = verible::AlignmentPolicy::kPreserve; + for (const auto &test_case : kTestCases) { + VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; + std::ostringstream stream; + const auto status = + FormatVerilog(test_case.input, "<filename>", style, stream); + // Require these test cases to be valid. + EXPECT_OK(status) << status.message(); + EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; + } +} + +TEST(FormatterEndToEndTest, DisableModuleInstantiations) { + static constexpr FormatterTestCase kTestCases[] = { + {"", ""}, + {"\n", "\n"}, + {"\n\n", "\n\n"}, + {"module m ;\t\n" + " endmodule\n", + "module m;\n" + "endmodule\n"}, + {"module m ;\t\n" + "foo bar();" + " endmodule\n", + "module m;\n" + " foo bar ();\n" // indentation still takes effect + "endmodule\n"}, + {"module m ;\t\n" + "logic xyz;" + "wire\tabc;" + " endmodule\n", + "module m;\n" + " logic xyz;\n" // indentation still takes effect + " wire abc;\n" // aligned too + "endmodule\n"}, + {" function f ;\t\n" + " endfunction\n", + "function f;\n" + "endfunction\n"}, + {" function f ;\t" + "foo bar,baz; " + " endfunction\n", + "function f;\n" + " foo bar, baz;\n" + "endfunction\n"}, + {" task t ;\t" + "foo bar,baz; " + " endtask\n", + "task t;\n" + " foo bar, baz;\n" + "endtask\n"}, + {"module m ;\t\n" + "foo bar( .baz(baz) );" + " endmodule\n", + "module m;\n" + " foo bar (.baz(baz));\n" // indentation still takes effect + "endmodule\n"}, + {"module m ;\t\n" + "foo bar(\n" + " .baz (baz ),\n" // example of user-manual alignment + " .blaaa(blaaa)\n" + ");" + " endmodule\n", + "module m;\n" + " foo bar (\n" // indentation still takes effect + " .baz (baz ),\n" // named port connections preserved + " .blaaa(blaaa)\n" // named port connections preserved + " );\n" // this indentation is fixed + "endmodule\n"}, + {"module m ;\t\n" + "foo #( .baz(baz) ) bar();" // named parameters + " endmodule\n", + "module m;\n" + " foo #(.baz(baz)) bar ();\n" // indentation still takes effect + "endmodule\n"}, + {"module m ;\t\n" + "foo #(\n" + " .baz (baz ),\n" // example of user-manual alignment + " .blaaa(blaaa)\n" + ") bar( );" + " endmodule\n", + "module m;\n" + " foo #(\n" // indentation still takes effect + " .baz (baz ),\n" // named parameter arguments preserved + " .blaaa(blaaa)\n" // named parameter arguments preserved + " ) bar ();\n" // this indentation is fixed + "endmodule\n"}, + }; + FormatStyle style; + style.column_limit = 40; + style.indentation_spaces = 2; + style.wrap_spaces = 4; + // Testing preservation of spaces + style.named_parameter_alignment = AlignmentPolicy::kPreserve; + style.named_port_alignment = AlignmentPolicy::kPreserve; + for (const auto &test_case : kTestCases) { + VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; + std::ostringstream stream; + const auto status = + FormatVerilog(test_case.input, "<filename>", style, stream); + // Require these test cases to be valid. + EXPECT_OK(status) << status.message(); + EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; + } +} + +TEST(FormatterEndToEndTest, DisableTryWrapLongLines) { + static constexpr FormatterTestCase kTestCases[] = { + {"", ""}, + {"\n", "\n"}, + {"\n\n", "\n\n"}, + {"module m ;\t\n" + " endmodule\n", + "module m;\n" + "endmodule\n"}, + {"module m( ) ;\n" + " endmodule\n", + "module m ();\n" + "endmodule\n"}, + {"module m( ) ;\n" + "initial assign a = b;\n" + " endmodule\n", + "module m ();\n" + " initial assign a = b;\n" + "endmodule\n"}, + {"module m( ) ;\n" + "initial assign a = {never +gonna +give +you +up,\n" + "never + gonna +Let +you +down};\n" + " endmodule\n", + "module m ();\n" + " initial\n" + " assign a = {\n" + " never + gonna + give + you + up,\n" + " never + gonna + Let + you + down\n" + " };\n" + "endmodule\n"}, + {"module m( ) ;\n" + "initial assign a = {never +gonna +give +you +up+\n" // over 40 columns, + // give up + "never + gonna +Let +you +down};\n" + " endmodule\n", + "module m ();\n" + " initial\n" + " assign a = {\n" + " never +gonna +give +you +up+\n" // indented properly, but + "never + gonna +Let +you +down\n" // preserved original + " };\n" + "endmodule\n"}, + {// The if-header is a single leaf partition, and does not fit, + // so its original spacing should be preserved. + // We deliberately insert weird spacing to show that it is preserved. + "function f;\n" + "if ((xxx.aaaa >= bbbbbbbbbbbbbbb) &&\n" + " ((ccc.ddd + eee.ffffff * g) <=\n" + " (hhhhhhhhhhhhhhh+iiiiiiiiiiiiiiiiiiii))) begin\n" + "end\n" + "endfunction\n", + "function f;\n" + " if ((xxx.aaaa >= bbbbbbbbbbbbbbb) &&\n" // indentation fixed + " ((ccc.ddd + eee.ffffff * g) <=\n" + " (hhhhhhhhhhhhhhh+iiiiiiiiiiiiiiiiiiii))) begin\n" + " end\n" // indentation fixed + "endfunction\n"}, + + // Make sure indentation still works with wrapping disabled, + // and leaf partitions fit on one line. + {"function void f();\n" + "for (int i = N; i > 0; i--) begin\n" + "end\n" + "endfunction\n", + "function void f();\n" + " for (int i = N; i > 0; i--) begin\n" + " end\n" + "endfunction\n"}, + {"function void f();" + "if(i > 0 ) begin end " + "endfunction", + "function void f();\n" + " if (i > 0) begin\n" + " end\n" + "endfunction\n"}, + {"function void f();" // newlines absent from input + "for (int i=N; i>0; i--) begin end " + "endfunction", + "function void f();\n" + " for (int i = N; i > 0; i--) begin\n" // spacing corrected + " end\n" + "endfunction\n"}, + {"module m( );\n" + " always_ff @ ( posedge ( clk ) ) begin\n" + "out <= rst_clk ? 0 : in ;\n" + "end\n" + "endmodule : simple\n", + "module m ();\n" + " always_ff @(posedge (clk)) begin\n" + " out <= rst_clk ? 0 : in;\n" + " end\n" + "endmodule : simple\n"}, + }; + FormatStyle style; + style.column_limit = 40; + style.indentation_spaces = 2; + style.wrap_spaces = 4; + style.try_wrap_long_lines = false; + for (const auto &test_case : kTestCases) { + VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; + std::ostringstream stream; + const auto status = + FormatVerilog(test_case.input, "<filename>", style, stream); + // Require these test cases to be valid. + EXPECT_OK(status) << status.message(); + EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; + } +} + +TEST(FormatterEndToEndTest, ModulePortDeclarationsIndentNotWrap) { + static constexpr FormatterTestCase kTestCases[] = { + {"", ""}, + {"\n", "\n"}, + {"\n\n", "\n\n"}, + {"module m ;\t\n" + " endmodule\n", + "module m;\n" + "endmodule\n"}, + {"module m( ) ;\n" + " endmodule\n", + "module m ();\n" // empty ports formatted compactly + "endmodule\n"}, + {// single port example + "module m ( input clk )\t;\n" + " endmodule\n", + "module m (\n" + " input clk\n" // 2 spaces + ");\n" + "endmodule\n"}, + {// example with two ports + "module m (\n" + "input clk,\n" + "output bar\n" + ")\t;\n" + " endmodule\n", + "module m (\n" + " input clk,\n" // indented 2 spaces, and aligned + " output bar\n" + ");\n" + "endmodule\n"}, + {// interface example + "interface handshake (\n" + "wire req,\n" + "wire ack\n" + ")\t;\n" + " endinterface\n", + "interface handshake (\n" + " wire req,\n" // indented 2 spaces + " wire ack\n" + ");\n" + "endinterface\n"}, + }; + FormatStyle style; + style.column_limit = 40; + style.indentation_spaces = 2; + style.wrap_spaces = 4; + // Indent 2 spaces instead of wrapping 4 spaces. + style.port_declarations_indentation = IndentationStyle::kIndent; + for (const auto &test_case : kTestCases) { + VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; + std::ostringstream stream; + const auto status = + FormatVerilog(test_case.input, "<filename>", style, stream); + // Require these test cases to be valid. + EXPECT_OK(status) << status.message(); + EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; + } +} + +TEST(FormatterEndToEndTest, NamedPortConnectionsIndentNotWrap) { + static constexpr FormatterTestCase kTestCases[] = { + {"", ""}, + {"\n", "\n"}, + {"\n\n", "\n\n"}, + {"module m ;\t\n" + " endmodule\n", + "module m;\n" + "endmodule\n"}, + {"module m( ) ;\n" + " endmodule\n", + "module m ();\n" // empty ports formatted compactly + "endmodule\n"}, + {// single port example + "module m ;\n" + "foo bar( .clk( clk ) )\t;\n" + " endmodule\n", + "module m;\n" + " foo bar (.clk(clk));\n" + "endmodule\n"}, + {// two port example + "module m ;\n" + "foo bar( .clk2( clk ),.data (data) )\t;\n" + " endmodule\n", + "module m;\n" + " foo bar (\n" + " .clk2(clk),\n" // indent only +2 spaces + " .data(data)\n" + " );\n" + "endmodule\n"}, + }; + FormatStyle style; + style.column_limit = 40; + style.indentation_spaces = 2; + style.wrap_spaces = 4; + // Indent 2 spaces instead of wrapping 4 spaces. + style.named_port_indentation = IndentationStyle::kIndent; + for (const auto &test_case : kTestCases) { + VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; + std::ostringstream stream; + const auto status = + FormatVerilog(test_case.input, "<filename>", style, stream); + // Require these test cases to be valid. + EXPECT_OK(status) << status.message(); + EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; + } +} + +TEST(FormatterEndToEndTest, WrapEndElseStatements) { + static constexpr FormatterTestCase kTestCases[] = { + {"module foo ();\n" + " always @(posedge bar) begin\n" + " if (1==1) begin\n" + " ham();\n" + " end else if (2==2) begin\n" + " jam();\n" + " end else begin\n" + " spam();\n" + " end\n" + " end\n" + "endmodule\n", + "module foo ();\n" + " always @(posedge bar) begin\n" + " if (1 == 1) begin\n" + " ham();\n" + " end\n" + " else if (2 == 2) begin\n" + " jam();\n" + " end\n" + " else begin\n" + " spam();\n" + " end\n" + " end\n" + "endmodule\n"}, + }; + FormatStyle style; + style.column_limit = 40; + style.indentation_spaces = 2; + style.wrap_spaces = 4; + style.wrap_end_else_clauses = true; + for (const auto &test_case : kTestCases) { + VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; + std::ostringstream stream; + const auto status = + FormatVerilog(test_case.input, "<filename>", style, stream); + // Require these test cases to be valid. + EXPECT_OK(status) << status.message(); + EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; + } +} + +TEST(FormatterEndToEndTest, FormalParametersIndentNotWrap) { + static constexpr FormatterTestCase kTestCases[] = { + {"", ""}, + {"\n", "\n"}, + {"\n\n", "\n\n"}, + {"module m ;\t\n" + " endmodule\n", + "module m;\n" + "endmodule\n"}, + {"module m #( ) ;\n" // empty parameters + " endmodule\n", + "module m #();\n" + "endmodule\n"}, + {// single parameter example + "module m #( int W = 2)\t;\n" + " endmodule\n", + "module m #(\n" + " int W = 2\n" // indented 2 spaces + ");\n" + "endmodule\n"}, + {// module with two parameters + "module m #(\n" + "int W = 2,\n" + "int L = 4\n" + ")\t;\n" + " endmodule\n", + "module m #(\n" + " int W = 2,\n" // indented 2 spaces + " int L = 4\n" + ");\n" + "endmodule\n"}, + {// interface with two parameters + "interface m #(\n" + "int W = 2,\n" + "int L = 4\n" + ")\t;\n" + " endinterface\n", + "interface m #(\n" + " int W = 2,\n" // indented 2 spaces + " int L = 4\n" + ");\n" + "endinterface\n"}, + {// class with two parameters + "class c #(\n" + "int W = 2,\n" + "int L = 4\n" + ")\t;\n" + " endclass\n", + "class c #(\n" + " int W = 2,\n" // indented 2 spaces + " int L = 4\n" + ");\n" + "endclass\n"}, + }; + FormatStyle style; + style.column_limit = 40; + style.indentation_spaces = 2; + style.wrap_spaces = 4; + // Indent 2 spaces instead of wrapping 4 spaces. + style.formal_parameters_indentation = IndentationStyle::kIndent; + for (const auto &test_case : kTestCases) { + VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; + std::ostringstream stream; + const auto status = + FormatVerilog(test_case.input, "<filename>", style, stream); + // Require these test cases to be valid. + EXPECT_OK(status) << status.message(); + EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; + } +} + +TEST(FormatterEndToEndTest, NamedParametersIndentNotWrap) { + static constexpr FormatterTestCase kTestCases[] = { + {"", ""}, + {"\n", "\n"}, + {"\n\n", "\n\n"}, + {"module m ;\t\n" + " endmodule\n", + "module m;\n" + "endmodule\n"}, + {"module m #( ) ;\n" // empty parameters + " endmodule\n", + "module m #();\n" + "endmodule\n"}, + {"module m ;\t\n" + " foo #()bar();\n" + " endmodule\n", + "module m;\n" + " foo #() bar ();\n" + "endmodule\n"}, + {// one named parameter + "module m ;\n" + "foo #(.W(1)) bar();\n" + " endmodule\n", + "module m;\n" + " foo #(.W(1)) bar ();\n" + "endmodule\n"}, + {// two named parameters + "module m ;\n" + "foo #(.W(1), .L(2)) bar();\n" + " endmodule\n", + "module m;\n" + " foo #(\n" + " .W(1),\n" // indent +2 spaces only + " .L(2)\n" + " ) bar ();\n" + "endmodule\n"}, + {// class data member with two parameters + "class c ;\n" + " foo_pkg::bar_t#(\n" + ".W(2),.L(4)" + ") baz;\n" + " endclass\n", + "class c;\n" + " foo_pkg::bar_t #(\n" + " .W(2),\n" // indent +2 spaces only + " .L(4)\n" + " ) baz;\n" + "endclass\n"}, + {// typedef with two parameters + "typedef \n" + " foo_pkg::bar_t #(" + ".W(2),.L(4)" + ") baz;\n", + "typedef foo_pkg::bar_t#(\n" + " .W(2),\n" // indent +2 spaces only + " .L(4)\n" + ") baz;\n"}, + }; + FormatStyle style; + style.column_limit = 40; + style.indentation_spaces = 2; + style.wrap_spaces = 4; + // Indent 2 spaces instead of wrapping 4 spaces. + style.named_parameter_indentation = IndentationStyle::kIndent; + for (const auto &test_case : kTestCases) { + VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; + std::ostringstream stream; + const auto status = + FormatVerilog(test_case.input, "<filename>", style, stream); + // Require these test cases to be valid. + EXPECT_OK(status) << status.message(); + EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; + } +} + +struct SelectLinesTestCase { + std::string_view input; + LineNumberSet lines; // explicit set of lines to enable formatting + std::string_view expected; +}; + +// Tests that formatter honors selected line numbers. +TEST(FormatterEndToEndTest, SelectLines) { + const SelectLinesTestCase kTestCases[] = { + {"", {}, ""}, + {"", {{1, 2}}, ""}, + {// expect all three lines for format + " parameter int foo_line1 = 0 ;\n" + " parameter int foo_line2 = 0 ;\n" + " parameter int foo_line3 = 0 ;\n", + {}, + "parameter int foo_line1 = 0;\n" + "parameter int foo_line2 = 0;\n" + "parameter int foo_line3 = 0;\n"}, + {// expect only one line to format + " parameter int foo_line1 = 0 ;\n" + " parameter int foo_line2 = 0 ;\n" + " parameter int foo_line3 = 0 ;\n", + {{1, 2}}, + "parameter int foo_line1 = 0;\n" + " parameter int foo_line2 = 0 ;\n" + " parameter int foo_line3 = 0 ;\n"}, + {// expect only one line to format + " parameter int foo_line1 = 0 ;\n" + " parameter int foo_line2 = 0 ;\n" + " parameter int foo_line3 = 0 ;\n", + {{2, 3}}, + " parameter int foo_line1 = 0 ;\n" + "parameter int foo_line2 = 0;\n" + " parameter int foo_line3 = 0 ;\n"}, + {// expect only one line to format + " parameter int foo_line1 = 0 ;\n" + " parameter int foo_line2 = 0 ;\n" + " parameter int foo_line3 = 0 ;\n", + {{3, 4}}, + " parameter int foo_line1 = 0 ;\n" + " parameter int foo_line2 = 0 ;\n" + "parameter int foo_line3 = 0;\n"}, + {// expect to format two lines + " parameter int foo_line1 = 0 ;\n" + " parameter int foo_line2 = 0 ;\n" + " parameter int foo_line3 = 0 ;\n", + {{1, 3}}, + "parameter int foo_line1 = 0;\n" + "parameter int foo_line2 = 0;\n" + " parameter int foo_line3 = 0 ;\n"}, + {// expect to format two lines + " parameter int foo_line1 = 0 ;\n" + " parameter int foo_line2 = 0 ;\n" + " parameter int foo_line3 = 0 ;\n", + {{2, 4}}, + " parameter int foo_line1 = 0 ;\n" + "parameter int foo_line2 = 0;\n" + "parameter int foo_line3 = 0;\n"}, + {// expect to format two lines + " parameter int foo_line1 = 0 ;\n" + " parameter int foo_line2 = 0 ;\n" + " parameter int foo_line3 = 0 ;\n", + {{1, 2}, {3, 4}}, + "parameter int foo_line1 = 0;\n" + " parameter int foo_line2 = 0 ;\n" + "parameter int foo_line3 = 0;\n"}, + {// expect to format all lines + " parameter int foo_line1 = 0 ;\n" + " parameter int foo_line2 = 0 ;\n" + " parameter int foo_line3 = 0 ;\n", + {{1, 4}}, + "parameter int foo_line1 = 0;\n" + "parameter int foo_line2 = 0;\n" + "parameter int foo_line3 = 0;\n"}, + {// expect to format no lines (line numbers out of bounds) + " parameter int foo_line1 = 0 ;\n" + " parameter int foo_line2 = 0 ;\n" + " parameter int foo_line3 = 0 ;\n", + {{4, 6}}, + " parameter int foo_line1 = 0 ;\n" + " parameter int foo_line2 = 0 ;\n" + " parameter int foo_line3 = 0 ;\n"}, + {// expect to format all lines + "// verilog_format: on\n" + " parameter int foo_line2 = 0 ;\n" + " parameter int foo_line3 = 0 ;\n" + " parameter int foo_line4 = 0 ;\n", + {}, + "// verilog_format: on\n" + "parameter int foo_line2 = 0;\n" + "parameter int foo_line3 = 0;\n" + "parameter int foo_line4 = 0;\n"}, + {// expect to format no lines + "// verilog_format: off\n" + " parameter int foo_line2 = 0 ;\n" + " parameter int foo_line3 = 0 ;\n" + " parameter int foo_line4 = 0 ;\n", + {}, + "// verilog_format: off\n" + " parameter int foo_line2 = 0 ;\n" + " parameter int foo_line3 = 0 ;\n" + " parameter int foo_line4 = 0 ;\n"}, + {// expect to format some lines + "// verilog_format: on\n" + " parameter int foo_line2 = 0 ;\n" + " parameter int foo_line3 = 0 ;\n" + " parameter int foo_line4 = 0 ;\n", + {{3, 5}}, + "// verilog_format: on\n" + " parameter int foo_line2 = 0 ;\n" + "parameter int foo_line3 = 0;\n" // disable lines 3,4 + "parameter int foo_line4 = 0;\n"}, + {// enable all lines, but respect format-off + " parameter int foo_line1 = 0 ;\n" + " parameter int foo_line2 = 0 ;\n" + "// verilog_format: off\n" + " parameter int foo_line4 = 0 ;\n", + {{1, 5}}, + "parameter int foo_line1 = 0;\n" + "parameter int foo_line2 = 0;\n" + "// verilog_format: off\n" + " parameter int foo_line4 = 0 ;\n"}, + {// enable all lines, but respect format-off + " parameter int foo_line1 = 0 ;\n" + "// verilog_format: off\n" + " parameter int foo_line3 = 0 ;\n" + "// verilog_format: on\n" + " parameter int foo_line5 = 0 ;\n", + {{1, 6}}, + "parameter int foo_line1 = 0;\n" + "// verilog_format: off\n" + " parameter int foo_line3 = 0 ;\n" + "// verilog_format: on\n" + "parameter int foo_line5 = 0;\n"}, + {// enable all lines, but respect format-off + "// verilog_format: off\n" + " parameter int foo_line2 = 0 ;\n" + " parameter int foo_line3 = 0 ;\n" + "// verilog_format: on\n" + " parameter int foo_line5 = 0 ;\n", + {{1, 6}}, + "// verilog_format: off\n" + " parameter int foo_line2 = 0 ;\n" + " parameter int foo_line3 = 0 ;\n" + "// verilog_format: on\n" + "parameter int foo_line5 = 0;\n"}, + {"module m;\n" + " if (foo) begin:l1\n" + " if (foo) begin:l2\n" + " always_comb\n" // normally this line and next would fit together + " d<=#1ps x_lat\t;\n" // only format this line, 5 + " end : l2\n" + " end : l1\n" + "endmodule\n", + {{5, 6}}, + "module m;\n" + " if (foo) begin:l1\n" + " if (foo) begin:l2\n" + " always_comb\n" // incremental mode prevents joining next line + " d <= #1ps x_lat;\n" // only this line changed + " end : l2\n" + " end : l1\n" + "endmodule\n"}, + + // Next three test cases: one whole-file, two incremental + {"module m(\n" + " input wire f,\n" + " input foo::bar ggg\n" + ");\n" + "endmodule:m\n", + {}, // format all lines + "module m (\n" + " input wire f,\n" + " input foo::bar ggg\n" + ");\n" + "endmodule : m\n"}, + {"module m(\n" + " input wire f,\n" + " input foo::bar ggg\n" // "new line", formatted incrementally + ");\n" + "endmodule:m\n", + {{3, 4}}, // format incrementally + "module m(\n" + " input wire f,\n" + " input foo::bar ggg\n" // "new line" remains untouched + ");\n" + "endmodule:m\n"}, + {"module m(\n" + " input wire f,\n" // "new line", formatted incrementally + " input foo::bar ggg\n" + ");\n" + "endmodule:m\n", + {{2, 3}}, // format incrementally + "module m(\n" + " input wire f,\n" // "new line" indented, but other spaces kept + " input foo::bar ggg\n" + ");\n" + "endmodule:m\n"}, + }; + // Use a fixed style. + FormatStyle style; + style.column_limit = 40; + style.indentation_spaces = 2; + style.wrap_spaces = 4; + for (const auto &test_case : kTestCases) { + VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; + std::ostringstream stream; + const auto status = FormatVerilog(test_case.input, "<filename>", style, + stream, test_case.lines); + EXPECT_OK(status) << status.message() << '\n' + << "Lines: " << test_case.lines; + EXPECT_EQ(stream.str(), test_case.expected) + << "code:\n" + << test_case.input << "\nlines: " << test_case.lines; + } +} + +// These tests verify the mode where horizontal spacing is discarded while +// vertical spacing is preserved. +TEST(FormatterEndToEndTest, PreserveVSpacesOnly) { + static constexpr FormatterTestCase kTestCases[] = { + // {input, expected}, + // No tokens cases: still preserve vertical spacing, but not horizontal + {"", ""}, + {" ", ""}, + {"\n", "\n"}, + {"\n\n", "\n\n"}, + {" \n", "\n"}, + {"\n ", "\n"}, + {" \n ", "\n"}, + {" \n \t\t\n\t ", "\n\n"}, + + // The remaining cases have at least one non-whitespace token. + + // single comment + {"//\n", "//\n"}, + {"// \n", "// \n"}, // trailing spaces inside comment untouched + {"\n//\n", "\n//\n"}, + {"\n\n//\n", "\n\n//\n"}, + {"\n//\n\n", "\n//\n\n"}, + {" //\n", "//\n"}, // spaces before comment discarded + {" \n //\n", "\n//\n"}, + {" \n //\n \n ", "\n//\n\n"}, // trailing spaces discarded + + // multi-comment + {"//\n//\n", "//\n//\n"}, + {"\n//\n\n//\n\n", "\n//\n\n//\n\n"}, + {"\n//\n\n//\n", "\n//\n\n//\n"}, // blank line between comments + + // Module cases with token partition boundary (before 'endmodule'). + {"module foo;endmodule\n", "module foo;\nendmodule\n"}, + {"module foo;\nendmodule\n", "module foo;\nendmodule\n"}, + {"module foo;\n\nendmodule\n", "module foo;\n\nendmodule\n"}, + {"\nmodule foo;endmodule\n", "\nmodule foo;\nendmodule\n"}, + {"\nmodule foo ; endmodule\n", "\nmodule foo;\nendmodule\n"}, + {"\nmodule\nfoo\n;endmodule\n", "\nmodule foo;\nendmodule\n"}, + {"\nmodule foo;endmodule\n\n\n", "\nmodule foo;\nendmodule\n\n\n"}, + {"\n\n\nmodule foo;endmodule\n", "\n\n\nmodule foo;\nendmodule\n"}, + {"\nmodule\nfoo\n;\n\n\nendmodule\n", "\nmodule foo;\n\n\nendmodule\n"}, + + // Module cases with one indented item, various original vertical spacing + {"module foo;wire w;endmodule\n", "module foo;\n wire w;\nendmodule\n"}, + {" module foo ;wire w ;endmodule \n ", + "module foo;\n wire w;\nendmodule\n"}, + {"\nmodule\nfoo\n;\nwire\nw\n;endmodule\n\n", + "\nmodule foo;\n wire w;\nendmodule\n\n"}, + {"\n\nmodule\nfoo\n;\n\n\nwire\nw\n;\n\nendmodule\n\n", + "\n\nmodule foo;\n\n\n wire w;\n\nendmodule\n\n"}, + + // The following cases show that some horizontal whitespace is discarded, + // while vertical spacing is preserved on partition boundaries. + {" module foo\t \t; endmodule \n", + "module foo;\nendmodule\n"}, + {"\t\n module foo\t\t; endmodule \n", + "\nmodule foo;\nendmodule\n"}, + + // Module with comments intermingled. + { + "//1\nmodule foo;//2\nwire w;//3\n//4\nendmodule\n", + "//1\nmodule foo; //2\n wire w; //3\n //4\nendmodule\n" + // TODO(fangism): whether or not //4 should be indented is + // questionable (in similar cases below too). + }, + {// now with extra blank lines + "//1\n\nmodule foo;//2\n\nwire w;//3\n\n//4\n\nendmodule\n\n", + "//1\n\nmodule foo; //2\n\n wire w; //3\n\n //4\n\nendmodule\n\n"}, + + { + // module with comments-only in some empty blocks, properly indented + " // humble module\n" + " module foo (// non-port comment\n" + "// port comment 1\n" + "// port comment 2\n" + ");// header trailing comment\n" + "// item comment 1\n" + "// item comment 2\n" + "endmodule\n", + "// humble module\n" + "module foo ( // non-port comment\n" + " // port comment 1\n" + " // port comment 2\n" + "); // header trailing comment\n" + " // item comment 1\n" + " // item comment 2\n" + "endmodule\n", + }, + + { + // module with comments around non-empty blocks + " // humble module\n" + " module foo (// non-port comment\n" + "// port comment 1\n" + "input logic f \n" + "// port comment 2\n" + ");// header trailing comment\n" + "// item comment 1\n" + "wire w ; \n" + "// item comment 2\n" + "endmodule\n", + "// humble module\n" + "module foo ( // non-port comment\n" + " // port comment 1\n" + " input logic f\n" + " // port comment 2\n" + "); // header trailing comment\n" + " // item comment 1\n" + " wire w;\n" + " // item comment 2\n" + "endmodule\n", + }, + }; + FormatStyle style; + for (const auto &test_case : kTestCases) { + VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; + std::ostringstream stream; + const auto status = + FormatVerilog(test_case.input, "<filename>", style, stream); + EXPECT_OK(status) << status.message(); + EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; + } +} + +static constexpr FormatterTestCase kFormatterTestCasesElseStatements[] = { + {"module m;" + "task static t; if (r == t) a.b(c); else d.e(f); endtask;" + "endmodule", + "module m;\n" + " task static t;\n" + " if (r == t) a.b(c);\n" + " else d.e(f);\n" + " endtask\n" + " ;\n" // possibly unintended stray ';' + "endmodule\n"}, + {"module m;" + "task static t; if (r == t) begin a.b(c); end else begin d.e(f); end " + "endtask;" + "endmodule", + "module m;\n" + " task static t;\n" + " if (r == t) begin\n" + " a.b(c);\n" + " end else begin\n" + " d.e(f);\n" + " end\n" + " endtask\n" + " ;\n" // stray ';' + "endmodule\n"}, + {"module m;initial begin if(a==b)" + "c.d(e);else\n" + "f.g(h);end endmodule", + "module m;\n" + " initial begin\n" + " if (a == b) c.d(e);\n" + " else f.g(h);\n" + " end\n" + "endmodule\n"}, + {" module m; always_comb begin \n" + " if ( a ) b = 16'hdead ; \n" + " else if ( c ) d= 16 'hbeef ; \n" + " else if (e) f=16'hca_fe ; \n" + "end \n endmodule\n", + "module m;\n" + " always_comb begin\n" + " if (a) b = 16'hdead;\n" + " else if (c) d = 16'hbeef;\n" + " else if (e) f = 16'hca_fe;\n" + " end\n" + "endmodule\n"}, + {"module foo();\n" + "always_comb begin\n" + "value = function_name(.long_parameter(8'hA), .parameter_three(foobar));\n" + "end\n" + "endmodule : foo\n", + "module foo ();\n" + " always_comb begin\n" + " value = function_name(\n" + " .long_parameter(8'hA),\n" + " .parameter_three(foobar)\n" + " );\n" + " end\n" + "endmodule : foo\n"}, + {"module foo();\n" + "always_comb begin\n" + "value = function_name(.a(1), .b(2));\n" + "end\n" + "endmodule : foo\n", + "module foo ();\n" + " always_comb begin\n" + " value = function_name(.a(1), .b(2));\n" + " end\n" + "endmodule : foo\n"}, + {"module foo ();\n" + "always_comb begin\n" + "value = function_name(8'hA, foobar, signal_1234); end\n" + "always_comb begin\n" + "value = function_name(8'hA, foobar); end\n" + "endmodule : foo\n", + "module foo ();\n" + " always_comb begin\n" + " value = function_name(8'hA, foobar,\n" + " signal_1234);\n" + " end\n" + " always_comb begin\n" + " value = function_name(8'hA, foobar);\n" + " end\n" + "endmodule : foo\n"}, + {"module foo ();\n" + "always_comb begin\n" + "value = function_name(8'hA, foobar, signal_1234);\n" + "value = function_name(8'hA, foobar, signal_1234); end\n" + "endmodule : foo\n", + "module foo ();\n" + " always_comb begin\n" + " value = function_name(8'hA, foobar,\n" + " signal_1234);\n" + " value = function_name(8'hA, foobar,\n" + " signal_1234);\n" + " end\n" + "endmodule : foo\n"}, + {"always_comb begin\n" + "value = " + "f(long_parameter_exceeding_col_limit, foo, bar); end\n", + "always_comb begin\n" + " value = f(\n" + " long_parameter_exceeding_col_limit,\n" + " foo,\n" + " bar\n" + " );\n" + "end\n"}, + {"module foo();\n" + "always_comb begin\n" + "value = function_name(8'hA, .parameter_three(foobar));\n" + "end\n" + "endmodule : foo\n", + "module foo ();\n" + " always_comb begin\n" + " value = function_name(\n" + " 8'hA,\n" + " .parameter_three(foobar)\n" + " );\n" + " end\n" + "endmodule : foo\n"}, + {"module foo ();\n" + "always_comb begin\n" + "value = function_name(8'hA, 8'hB, 8'hC, .parameter_four(foo), " + ".par_five(bar));\n" + "end\n" + "endmodule : foo\n", + "module foo ();\n" + " always_comb begin\n" + " value = function_name(\n" + " 8'hA,\n" + " 8'hB,\n" + " 8'hC,\n" + " .parameter_four(foo),\n" + " .par_five(bar)\n" + " );\n" + " end\n" + "endmodule : foo\n"}, + {"class dv_base_mem; function void configure(); \nbegin\n" + "value = func(8'hA, foobar, signal_1234);\n" + "value = new(8'hA, foobar, signal_1234); end\n" + "endfunction : configure endclass\n", + "class dv_base_mem;\n" + " function void configure();\n" + " begin\n" + " value = func(8'hA, foobar,\n" + " signal_1234);\n" + " value = new(8'hA, foobar,\n" + " signal_1234);\n" + " end\n" + " endfunction : configure\n" + "endclass\n"}, + {"module m; initial begin\n" + " if (a||b) c = 1'b1;\n" + "d = 1'b1; if (e)\n" + "begin f = 1'b0; end else begin\n" + " g = h;\n" + " end \n" + " i = 1'b1; " + "end endmodule\n", + "module m;\n" + " initial begin\n" + " if (a || b) c = 1'b1;\n" + " d = 1'b1;\n" + " if (e) begin\n" + " f = 1'b0;\n" + " end else begin\n" + " g = h;\n" + " end\n" + " i = 1'b1;\n" + " end\n" + "endmodule\n"}, + {"module m; initial begin\n" + "if (a&&b&&c) begin\n" + " d = 1'b1;\n" + " if (e) begin\n" + " f = ff;\n" + " end else if ( g ) begin\n" + " h = hh;\n" + "end else if (i) begin\n" + " j = (kk == ll) ? mm :\n" + " gg;\n" + " end else if ( qq ) begin\n" + " if ( xx ||yy ) begin d0 = 1'b0; d1 = " + "1'b1;\n" + " end else if (oo) begin aa = bb; cc = dd;" + " if (zz) zx = xz; else ba = ab;" + " end else \n begin vv = tt ; \n" + " end end " + "end \n else if (uu)\nbegin\n\na=b;if (aa) b = c;\n" + "\nelse if \n (bb) \n\nc =d ;\n\n\n\n\n " + " else e\n\n = h;\n\n" + "end \n else \n begin if(x)y=a;else\nbegin\n" + "\n\n\na=y; if (a) b = c;\n\n\n\nelse\n\n\nd=e;end \n" + "end\n" + "end endmodule\n", + "module m;\n" + " initial begin\n" + " if (a && b && c) begin\n" + " d = 1'b1;\n" + " if (e) begin\n" + " f = ff;\n" + " end else if (g) begin\n" + " h = hh;\n" + " end else if (i) begin\n" + " j = (kk == ll) ? mm : gg;\n" + " end else if (qq) begin\n" + " if (xx || yy) begin\n" + " d0 = 1'b0;\n" + " d1 = 1'b1;\n" + " end else if (oo) begin\n" + " aa = bb;\n" + " cc = dd;\n" + " if (zz) zx = xz;\n" + " else ba = ab;\n" + " end else begin\n" + " vv = tt;\n" + " end\n" + " end\n" + " end else if (uu) begin\n\n" + " a = b;\n" + " if (aa) b = c;\n\n" + " else if (bb) c = d;\n\n\n\n\n" + " else e = h;\n\n" + " end else begin\n" + " if (x) y = a;\n" + " else begin\n\n\n\n" + " a = y;\n" + " if (a) b = c;\n\n\n\n" + " else d = e;\n" + " end\n" + " end\n" + " end\n" + "endmodule\n"}}; + +TEST(FormatterEndToEndTest, FormatElseStatements) { + // Use a fixed style. + FormatStyle style; + style.column_limit = 40; + style.indentation_spaces = 2; + style.wrap_spaces = 4; + for (const auto &test_case : kFormatterTestCasesElseStatements) { + VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; + std::ostringstream stream; + const auto status = + FormatVerilog(test_case.input, "<filename>", style, stream); + EXPECT_OK(status) << status.message(); + EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; + } +} + +TEST(FormatterEndToEndTest, ConstraintExpressions) { + static constexpr FormatterTestCase kTestCases[] = { + {"", ""}, + + // class members + {"class Foo; constraint if_c { if (zzzzzzzzzzzzzzzzzzzzz)" + "{ soft xxxxxxxxxxxxxxxxxxxxxx == yyyyyyyyyyyyyyyyyyy; } } endclass", + "class Foo;\n" + " constraint if_c {\n" + " if (zzzzzzzzzzzzzzzzzzzzz) {\n" + " soft xxxxxxxxxxxxxxxxxxxxxx == yyyyyyyyyyyyyyyyyyy;\n" + " }\n" + " }\n" + "endclass\n"}, + + // constraints with if-constraint expressions + {"constraint xx { if (a) b; }\n", "constraint xx {if (a) b;}\n"}, + + {"constraint xx { if (a) {b;} }\n", + "constraint xx {\n" + " if (a) {\n" + " b;\n" + " }\n" + "}\n"}, + + // multi item constraint + {"constraint yy { a == b;c==d;}", + "constraint yy {\n" + " a == b;\n" + " c == d;\n" + "}\n"}, + + // one-line constraints + {"constraint only_vec_instr_c {soft only_vec_instr == 0;}", + "constraint only_vec_instr_c {soft only_vec_instr == 0;}\n"}, + + {"constraint\nnum_trans_c\n\n\n{\n\n\nnum_trans inside{[800:1000]};}", + "constraint num_trans_c {num_trans inside {[800 : 1000]};}\n"}, + + // if-vs-concatenation expression + {"constraint c_operation{ if(fixed_operation_en){" + "aes_operation == fixed_operation" + ";}}", + "constraint c_operation {\n" + " if (fixed_operation_en) {\n" + " aes_operation == fixed_operation;\n" + " }\n" + "}\n"}, + + {"constraint c_operation{ if(fixed_operation_en){" + "aes_operation == fixed_operation" + "};}", + "constraint c_operation {\n" + " if (fixed_operation_en)\n" + " {aes_operation == fixed_operation};\n" + "}\n"}, + + // concatenation expression + {"constraint c_iv {if (fixed_iv_en) {aes_iv == fixed_iv};}", + "constraint c_iv {\n" + " if (fixed_iv_en)\n" + " {aes_iv == fixed_iv};\n" + "}\n"}, + + // looooong test + {"constraint xx {" + "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)" + "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa==" + "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;" + "ccccccccccccccccccccccc==dddddddddddddddddddddd;}", + "constraint xx {\n" + " if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n" + " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == " + "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;\n" + " ccccccccccccccccccccccc == dddddddddddddddddddddd;\n" + "}\n"}, + }; + FormatStyle style; + style.column_limit = + 100; // smaller column_limit forces expansion of constraint blocks + style.indentation_spaces = 2; + style.wrap_spaces = 4; + style.port_declarations_alignment = verible::AlignmentPolicy::kPreserve; + for (const auto &test_case : kTestCases) { + VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; + std::ostringstream stream; + const auto status = + FormatVerilog(test_case.input, "<filename>", style, stream); + // Require these test cases to be valid. + EXPECT_OK(status) << status.message(); + EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; + } +} + +static constexpr FormatterTestCase kFormatterTestCasesEnumDeclarations[] = { + // Inferring user intent: not too many spaces to be added: align. + {"typedef enum { kA=1, kAB=2, kABC=3} x;", + "typedef enum {\n" + " kA = 1,\n" + " kAB = 2,\n" + " kABC = 3\n} x;\n"}, + + // Lots of spaces would've to be be added - keep flush + {"typedef enum { kA=1, kAB=2, kABCDEFGHIJKLMN=3} x;", + "typedef enum {\n" + " kA = 1,\n" + " kAB = 2,\n" + " kABCDEFGHIJKLMN = 3\n} x;\n"}, + + // Source spaces indicate alignment wish. + {"typedef enum { kA =1, kAB=2, kABCDEFGHIJKLMN=3} x;", + "typedef enum {\n" + " kA = 1,\n" + " kAB = 2,\n" + " kABCDEFGHIJKLMN = 3\n} x;\n"}, + + // An empty line groups into several sections, to be aligned independently + {"typedef enum { kA=1, kAB=2, \n\n kABC=3} x;", + "typedef enum {\n" + " kA = 1,\n" + " kAB = 2,\n" + "\n" + " kABC = 3\n} x;\n"}, + + // Lines with comments don't interrupt alignment + {"typedef enum { kA=1,\n" + "// hello world\n" + "kAB=2, kABC=3} x;", + "typedef enum {\n" + " kA = 1,\n" + " // hello world\n" + " kAB = 2,\n" + " kABC = 3\n} x;\n"}, + + // Generally, comment locations are preserved, and full line comments + // indented to enum name level. + {"typedef enum { kA=1,// value kA\n" + "// hello world\n" + "kAB=2,// value kAB\n" + "kABC=3// value kABC\n" + "} x;", + "typedef enum {\n" + " kA = 1, // value kA\n" + " // hello world\n" + " kAB = 2, // value kAB\n" + " kABC = 3 // value kABC" + "\n} x;\n"}, + + {"typedef enum { kA=1,// value kA\n" + "kAB=2,\n" + "kABC=3// value kABC\n" + "} x;", + "typedef enum {\n" + " kA = 1, // value kA\n" + " kAB = 2,\n" + " kABC = 3 // value kABC" + "\n} x;\n"}, + + // Numeric constants are currently flushed left, but maybe todo + // align right in the future ? + {"typedef enum { kA=1, kAB=10, kABC=100} x;", + "typedef enum {\n" + " kA = 1,\n" + " kAB = 10,\n" + " kABC = 100\n} x;\n"}, +}; + +TEST(FormatterEndToEndTest, FormatAlignEnumDeclarations) { + // Use a fixed style. + FormatStyle style; + style.column_limit = 40; + style.indentation_spaces = 2; + style.wrap_spaces = 4; + style.enum_assignment_statement_alignment = AlignmentPolicy::kInferUserIntent; + for (const auto &test_case : kFormatterTestCasesEnumDeclarations) { + VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; + std::ostringstream stream; + const auto status = + FormatVerilog(test_case.input, "<filename>", style, stream); + EXPECT_OK(status) << status.message(); + EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; + } +} + +TEST(FormatterEndToEndTest, DiagnosticShowFullTree) { + // Use a fixed style. + FormatStyle style; + style.column_limit = 40; + style.indentation_spaces = 2; + style.wrap_spaces = 4; + for (const auto &test_case : kDiagnosticFormatterTestCases) { + std::ostringstream stream, debug_stream; + ExecutionControl control; + control.stream = &debug_stream; + control.show_token_partition_tree = true; + const auto status = FormatVerilog(test_case.input, "<filename>", style, + stream, kEnableAllLines, control); + EXPECT_EQ(status.code(), StatusCode::kCancelled); + EXPECT_TRUE( + absl::StartsWith(debug_stream.str(), "Full token partition tree")); + } +} + +TEST(FormatterEndToEndTest, DiagnosticLargestPartitions) { + // Use a fixed style. + FormatStyle style; + style.column_limit = 40; + style.indentation_spaces = 2; + style.wrap_spaces = 4; + for (const auto &test_case : kDiagnosticFormatterTestCases) { + std::ostringstream stream, debug_stream; + ExecutionControl control; + control.stream = &debug_stream; + control.show_largest_token_partitions = 2; + const auto status = FormatVerilog(test_case.input, "<filename>", style, + stream, kEnableAllLines, control); + EXPECT_EQ(status.code(), StatusCode::kCancelled); + EXPECT_TRUE(absl::StartsWith(debug_stream.str(), "Showing the ")) + << "got: " << debug_stream.str(); + } +} + +TEST(FormatterEndToEndTest, DiagnosticEquallyOptimalWrappings) { + // Use a fixed style. + FormatStyle style; + style.column_limit = 40; + style.indentation_spaces = 2; + style.wrap_spaces = 4; + for (const auto &test_case : kDiagnosticFormatterTestCases) { + std::ostringstream stream, debug_stream; + ExecutionControl control; + control.stream = &debug_stream; + control.show_equally_optimal_wrappings = true; + const auto status = FormatVerilog(test_case.input, "<filename>", style, + stream, kEnableAllLines, control); + EXPECT_OK(status) << status.message(); + if (!debug_stream.str().empty()) { + EXPECT_TRUE(absl::StartsWith(debug_stream.str(), "Showing the ")) + << "got: " << debug_stream.str(); + // Cannot guarantee among unit tests that there will be >1 solution. + } + } +} + +// Test that hitting search space limit results in correct error status. +TEST(FormatterEndToEndTest, UnfinishedLineWrapSearching) { + FormatStyle style; + style.column_limit = 40; + style.indentation_spaces = 2; + style.wrap_spaces = 4; + + const std::string_view code("parameter int x = 1+1;\n"); + + std::ostringstream stream, debug_stream; + ExecutionControl control; + control.max_search_states = 2; // Cause search to abort early. + control.stream = &debug_stream; + const auto status = FormatVerilog(code, "<filename>", style, stream, + kEnableAllLines, control); + EXPECT_EQ(status.code(), StatusCode::kResourceExhausted); + EXPECT_TRUE(absl::StartsWith(status.message(), "***")); +} + +static constexpr FormatterTestCase kOnelineFormatBaselineTestCases[] = { + // Reference - following test cases should not be affected by the switch + {// Minimal useful case + "covergroup c @ (posedge clk); coverpoint a; endgroup\n", + "covergroup c @(posedge clk);\n" + " coverpoint a;\n" + "endgroup\n"}, + {// Multiple coverpoints + "covergroup foo @(posedge clk); coverpoint a; coverpoint b; " + "coverpoint c; coverpoint d; endgroup\n", + "covergroup foo @(posedge clk);\n" + " coverpoint a;\n" + " coverpoint b;\n" + " coverpoint c;\n" + " coverpoint d;\n" + "endgroup\n"}, + {// Multiple bins + "covergroup memory @ (posedge ce); address :coverpoint addr {" + "bins low={LOW}; bins high={HIGH};} endgroup\n", + "covergroup memory @(posedge ce);\n" + " address: coverpoint addr {\n" + " bins low = {LOW};\n" + " bins high = {HIGH};\n" + " }\n" + "endgroup\n"}, + {// Multiple bins with multiple elements + "covergroup memory @ (posedge ce); address :coverpoint addr {" + "bins low={0,127}; bins high={128,255};} endgroup\n", + "covergroup memory @(posedge ce);\n" + " address: coverpoint addr {\n" + " bins low = {0, 127};\n" + " bins high = {128, 255};\n" + " }\n" + "endgroup\n"}, +}; + +// Tests that constructs that could be formatted as one-liners are formatted +// correctly. This is the baseline test with default style, test cases should +// not be affected by the setting. +TEST(FormatterEndToEndTest, OnelineFormatBaselineTest) { + // Use a fixed style. + FormatStyle style; + style.column_limit = 40; + style.indentation_spaces = 2; + style.wrap_spaces = 4; + style.expand_coverpoints = false; + for (const auto &test_case : kOnelineFormatBaselineTestCases) { + VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; + std::ostringstream stream; + const auto status = + FormatVerilog(test_case.input, "<filename>", style, stream); + // Require these test cases to be valid. + EXPECT_OK(status) << status.message(); + EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; + } + // Test again with the switch, should not affect formatting + style.expand_coverpoints = true; + for (const auto &test_case : kOnelineFormatBaselineTestCases) { + VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; + std::ostringstream stream; + const auto status = + FormatVerilog(test_case.input, "<filename>", style, stream); + // Require these test cases to be valid. + EXPECT_OK(status) << status.message(); + EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; + } +} + +// Following two test sets are affected by the expand_coverponits switch +// They should contain corresponding test cases +static constexpr FormatterTestCase kOnelineFormatReferenceTestCases[] = { + {// Coverpoint that could fit on one line + "covergroup memory @ (posedge ce); a :coverpoint d {" + "bins l={0};} endgroup\n", + "covergroup memory @(posedge ce);\n" + " a: coverpoint d {bins l = {0};}\n" + "endgroup\n"}, + {// Fit with a reference + "covergroup memory @ (posedge ce); a :coverpoint d {" + "bins l={LOW};} endgroup\n", + "covergroup memory @(posedge ce);\n" + " a: coverpoint d {bins l = {LOW};}\n" + "endgroup\n"}, + {// Fit with multiple elements + "covergroup memory @ (posedge ce); a :coverpoint d {" + "bins l={0,8};} endgroup\n", + "covergroup memory @(posedge ce);\n" + " a: coverpoint d {bins l = {0, 8};}\n" + "endgroup\n"}, +}; + +static constexpr FormatterTestCase kOnelineFormatExpandTestCases[] = { + {// Coverpoint that could fit on one line + "covergroup memory @ (posedge ce); a :coverpoint d {" + "bins l={0};} endgroup\n", + "covergroup memory @(posedge ce);\n" + " a: coverpoint d {\n" + " bins l = {0};\n" + " }\n" + "endgroup\n"}, + {// Fit with a reference + "covergroup memory @ (posedge ce); a :coverpoint d {" + "bins l={LOW};} endgroup\n", + "covergroup memory @(posedge ce);\n" + " a: coverpoint d {\n" + " bins l = {LOW};\n" + " }\n" + "endgroup\n"}, + {// Fit with multiple elements + "covergroup memory @ (posedge ce); a :coverpoint d {" + "bins l={0,8};} endgroup\n", + "covergroup memory @(posedge ce);\n" + " a: coverpoint d {\n" + " bins l = {0, 8};\n" + " }\n" + "endgroup\n"}, +}; + +TEST(FormatterEndToEndTest, OnelineFormatReferenceTest) { + // Use a fixed style. + FormatStyle style; + style.column_limit = 40; + style.indentation_spaces = 2; + style.wrap_spaces = 4; + style.expand_coverpoints = false; + + for (const auto &test_case : kOnelineFormatReferenceTestCases) { + VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; + std::ostringstream stream; + const auto status = + FormatVerilog(test_case.input, "<filename>", style, stream); + // Require these test cases to be valid. + EXPECT_OK(status) << status.message(); + EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; + } +} + +// Tests that constructs that could be formatted as one-liners are expanded +// correctly. This is the baseline test with default style +TEST(FormatterEndToEndTest, OnelineFormatExpandTest) { + // Use a fixed style. + FormatStyle style; + style.column_limit = 40; + style.indentation_spaces = 2; + style.wrap_spaces = 4; + style.expand_coverpoints = true; + + for (const auto &test_case : kOnelineFormatExpandTestCases) { + VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; + std::ostringstream stream; + const auto status = + FormatVerilog(test_case.input, "<filename>", style, stream); + // Require these test cases to be valid. + EXPECT_OK(status) << status.message(); + EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; + } +} + +struct DimensionsAlignmentTestCase { + std::string_view input; + std::string_view expected[4]; +}; + +static constexpr DimensionsAlignmentTestCase + kPortDeclarationDimensionsAlignmentTestCases[] = { + {"import \"DPI-C\" context function void func(\n" + "input bit foo,\n" + "input bit [2] foobar,\n" + "input bit [24:16] bar,\n" + "input bit [2:0][31:0] baz,\n" + "input bit [4][24:0][16:0] foobarbaz[],\n" + "input bit [FOOBAZ][31:24] qux[16],\n" + "input bit [16] quux[8:2][16][32],\n" + "output bit [2:0][2:0][2:0] quuz[8][16:12]\n" + ");\n", + { + "import \"DPI-C\" context function void func(\n" + " input bit foo,\n" + " input bit [ 2] foobar,\n" + " input bit [ 24:16] bar,\n" + " input bit [ 2:0][ 31:0] baz,\n" + " input bit [ 4][ 24:0][16:0] foobarbaz[ ],\n" + " input bit [FOOBAZ][31:24] qux [ 16],\n" + " input bit [ 16] quux [8:2][ 16][32],\n" + " output bit [ 2:0][ 2:0][ 2:0] quuz [ 8][16:12]\n" + ");\n", + "import \"DPI-C\" context function void func(\n" + " input bit foo,\n" + " input bit [ 2] foobar,\n" + " input bit [ 24:16] bar,\n" + " input bit [ 2:0][ 31:0] baz,\n" + " input bit [ 4][ 24:0][16:0] foobarbaz [ ],\n" + " input bit [FOOBAZ][31:24] qux [ 16],\n" + " input bit [ 16] quux [8:2][16][ 32],\n" + " output bit [ 2:0][ 2:0][ 2:0] quuz [ 8][16:12]\n" + ");\n", + "import \"DPI-C\" context function void func(\n" + " input bit foo,\n" + " input bit [ 2] foobar,\n" + " input bit [24:16] bar,\n" + " input bit [ 2:0][ 31:0] baz,\n" + " input bit [ 4][ 24:0][ 16:0] foobarbaz[ ],\n" + " input bit [FOOBAZ][31:24] qux [ 16],\n" + " input bit [ 16] quux [8:2][ 16][32],\n" + " output bit [2:0][ 2:0][ 2:0] quuz [ 8][16:12]\n" + ");\n", + "import \"DPI-C\" context function void func(\n" + " input bit foo,\n" + " input bit [ 2] foobar,\n" + " input bit [24:16] bar,\n" + " input bit [ 2:0][ 31:0] baz,\n" + " input bit [ 4][ 24:0][ 16:0] foobarbaz [ ],\n" + " input bit [FOOBAZ][31:24] qux [ 16],\n" + " input bit [ 16] quux [8:2][16][ 32],\n" + " output bit [2:0][ 2:0][ 2:0] quuz [ 8][16:12]\n" + ");\n", + }}, + {"module m(\n" + "output bit [2:0][2:0][2:0] quuz[8][16:12],\n" + "input bit [16] quux[8:2][16][32],\n" + "input bit [FOOBAZ][31:24] qux[16],\n" + "input bit [4][24:0][16:0] foobaz[],\n" + "input bit [2:0][31:0] baz,\n" + "input bit [24:16] bar,\n" + "input bit [2] foobar,\n" + "input bit foo\n" + "); endmodule:m\n", + { + "module m (\n" + " output bit [ 2:0][ 2:0][ 2:0] quuz [ 8][16:12],\n" + " input bit [ 16] quux [8:2][ 16][32],\n" + " input bit [FOOBAZ][31:24] qux [ 16],\n" + " input bit [ 4][ 24:0][16:0] foobaz[ ],\n" + " input bit [ 2:0][ 31:0] baz,\n" + " input bit [ 24:16] bar,\n" + " input bit [ 2] foobar,\n" + " input bit foo\n" + ");\n" + "endmodule : m\n", + "module m (\n" + " output bit [ 2:0][ 2:0][ 2:0] quuz [ 8][16:12],\n" + " input bit [ 16] quux [8:2][16][ 32],\n" + " input bit [FOOBAZ][31:24] qux [ 16],\n" + " input bit [ 4][ 24:0][16:0] foobaz [ ],\n" + " input bit [ 2:0][ 31:0] baz,\n" + " input bit [ 24:16] bar,\n" + " input bit [ 2] foobar,\n" + " input bit foo\n" + ");\n" + "endmodule : m\n", + "module m (\n" + " output bit [2:0][ 2:0][ 2:0] quuz [ 8][16:12],\n" + " input bit [ 16] quux [8:2][ 16][32],\n" + " input bit [FOOBAZ][31:24] qux [ 16],\n" + " input bit [ 4][ 24:0][ 16:0] foobaz[ ],\n" + " input bit [ 2:0][ 31:0] baz,\n" + " input bit [24:16] bar,\n" + " input bit [ 2] foobar,\n" + " input bit foo\n" + ");\n" + "endmodule : m\n", + "module m (\n" + " output bit [2:0][ 2:0][ 2:0] quuz [ 8][16:12],\n" + " input bit [ 16] quux [8:2][16][ 32],\n" + " input bit [FOOBAZ][31:24] qux [ 16],\n" + " input bit [ 4][ 24:0][ 16:0] foobaz [ ],\n" + " input bit [ 2:0][ 31:0] baz,\n" + " input bit [24:16] bar,\n" + " input bit [ 2] foobar,\n" + " input bit foo\n" + ");\n" + "endmodule : m\n", + }}, +}; + +TEST(FormatterEndToEndTest, PortDeclarationDimensionsAlignmentTest) { + FormatStyle style; + style.column_limit = 64; + style.indentation_spaces = 2; + style.wrap_spaces = 4; + + // All combinations of port_declaration_right_align_{un,}packed_dimensions + static const bool right_align_combinations[][2] = { + {false, false}, {false, true}, {true, false}, {true, true}}; + + for (const auto &test_case : kPortDeclarationDimensionsAlignmentTestCases) { + VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; + size_t expected_index = 0; + for (const auto &right_align : right_align_combinations) { + VLOG(1) << "style variant:\n" + << "port_declarations_right_align_packed_dimensions: " + << right_align[0] << "\n" + << "port_declarations_right_align_unpacked_dimensions: " + << right_align[1] << "\n"; + style.port_declarations_right_align_packed_dimensions = right_align[0]; + style.port_declarations_right_align_unpacked_dimensions = right_align[1]; + + std::ostringstream stream; + + const auto status = + FormatVerilog(test_case.input, "<filename>", style, stream); + // Require these test cases to be valid. + EXPECT_OK(status) << status.message(); + EXPECT_EQ(stream.str(), test_case.expected[expected_index++]) + << "code:\n" + << test_case.input; + } + } +} + +// TODO(fangism): directed tests using style variations + +static constexpr FormatterTestCase kNestedFunctionsTestCases40ColumnsLimit[] = { + {"module foo;" + "`uvm_info(`gfn, $sformatf(\n" + "\"\\n base_vseq: generate %0d pulse in channel %0d\", cfg.num_pulses, " + "i), UVM_DEBUG)\n" + "endmodule", + "module foo;\n" + " `uvm_info(\n" + " `gfn,\n" + " $sformatf(\n" + " \"\\n base_vseq: generate %0d pulse in channel %0d\",\n" + " cfg.num_pulses, i), UVM_DEBUG)\n" + "endmodule\n"}, + {"module foo;`uvm_info(`gfn, $sformatf(" + "\"\\n\\n\\t ----| STARTING AES MAIN SEQUENCE |----\\n %s\"," + "cfg.convert2string()), UVM_LOW)\n" + "endmodule", + "module foo;\n" + " `uvm_info(\n" + " `gfn,\n" + " $sformatf(\n" + " \"\\n\\n\\t ----| STARTING AES MAIN SEQUENCE |----\\n %s\",\n" + " cfg.convert2string()),\n" + " UVM_LOW)\n" // FIXME: Wrapped by SearchLineWraps + "endmodule\n"}, +}; + +TEST(FormatterEndToEndTest, FormatNestedFunctionsTestCases40ColumnsLimit) { + // Use a fixed style. + FormatStyle style; + style.column_limit = 40; + style.indentation_spaces = 2; + style.wrap_spaces = 4; + + for (const auto &test_case : kNestedFunctionsTestCases40ColumnsLimit) { + VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; + std::ostringstream stream; + const auto status = + FormatVerilog(test_case.input, "<filename>", style, stream); + // Require these test cases to be valid. + EXPECT_OK(status) << status.message(); + EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; + } +} + +static constexpr FormatterTestCase kNestedFunctionsTestCases60ColumnsLimit[] = { + {"module foo;" + "`uvm_info(`gfn, $sformatf(\n" + "\"\\n base_vseq: generate %0d pulse in channel %0d\", cfg.num_pulses, " + "i), UVM_DEBUG)\n" + "endmodule", + "module foo;\n" + " `uvm_info(\n" + " `gfn,\n" + " $sformatf(\n" + " \"\\n base_vseq: generate %0d pulse in channel %0d\",\n" + " cfg.num_pulses, i), UVM_DEBUG)\n" + "endmodule\n"}, + {"module foo;`uvm_info(`gfn, $sformatf(" + "\"\\n\\n\\t ----| STARTING AES MAIN SEQUENCE |----\\n %s\"," + "cfg.convert2string()), UVM_LOW)\n" + "endmodule", + "module foo;\n" + " `uvm_info(\n" + " `gfn,\n" + " $sformatf(\n" + " \"\\n\\n\\t ----| STARTING AES MAIN SEQUENCE |----\\n %s\",\n" + " cfg.convert2string()), UVM_LOW)\n" + "endmodule\n"}, +}; + +TEST(FormatterEndToEndTest, FormatNestedFunctionsTestCases60ColumnsLimit) { + // Use a fixed style. + FormatStyle style; + style.column_limit = 60; + style.indentation_spaces = 2; + style.wrap_spaces = 4; + + for (const auto &test_case : kNestedFunctionsTestCases60ColumnsLimit) { + VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; + std::ostringstream stream; + const auto status = + FormatVerilog(test_case.input, "<filename>", style, stream); + // Require these test cases to be valid. + EXPECT_OK(status) << status.message(); + EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; + } +} + +static constexpr FormatterTestCase kNestedFunctionsTestCases80ColumnsLimit[] = { + {"module foo;" + "`uvm_info(`gfn, $sformatf(\n" + "\"\\n base_vseq: generate %0d pulse in channel %0d\", cfg.num_pulses, " + "i), UVM_DEBUG)\n" + "endmodule", + "module foo;\n" + " `uvm_info(`gfn, $sformatf(\"\\n base_vseq: generate %0d pulse in " + "channel %0d\",\n" + " cfg.num_pulses, i), UVM_DEBUG)\n" + "endmodule\n"}, + {"module foo;`uvm_info(`gfn, $sformatf(" + "\"\\n\\n\\t ----| STARTING AES MAIN SEQUENCE |----\\n %s\"," + "cfg.convert2string()), UVM_LOW)\n" + "endmodule", + "module foo;\n" + " `uvm_info(`gfn, $sformatf(\n" + " \"\\n\\n\\t ----| STARTING AES MAIN SEQUENCE " + "|----\\n %s\",\n" + " cfg.convert2string()), UVM_LOW)\nendmodule\n"}, + {"module x;" + "`uvm_fatal(`gfn, $sformatf(" + "\"The data 0x%0h written to the signature address is formatted " + "incorrectly.\"," + "signature_data))\n" + "endmodule", + "module x;\n" + " `uvm_fatal(\n" + " `gfn,\n" + " $sformatf(\n" + " \"The data 0x%0h written to the signature address is formatted " + "incorrectly.\",\n" + " signature_data))\n" + "endmodule\n"}, +}; + +TEST(FormatterEndToEndTest, FormatNestedFunctionsTestCases80ColumnsLimit) { + // Use a fixed style. + FormatStyle style; + style.column_limit = 80; + style.indentation_spaces = 2; + style.wrap_spaces = 4; + + for (const auto &test_case : kNestedFunctionsTestCases80ColumnsLimit) { + VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; + std::ostringstream stream; + const auto status = + FormatVerilog(test_case.input, "<filename>", style, stream); + // Require these test cases to be valid. + EXPECT_OK(status) << status.message(); + EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; + } +} + +static constexpr FormatterTestCase kNestedFunctionsTestCases100ColumnsLimit[] = + { + {"module foo;" + "`uvm_info(`gfn, $sformatf(\n" + "\"\\n base_vseq: generate %0d pulse in channel %0d\", " + "cfg.num_pulses, i), UVM_DEBUG)\n" + "endmodule", + "module foo;\n" + " `uvm_info(`gfn, $sformatf(\"\\n base_vseq: generate %0d pulse in " + "channel %0d\", cfg.num_pulses, i),\n" + " UVM_DEBUG)\n" + "endmodule\n"}, + {"module foo;`uvm_info(`gfn, $sformatf(" + "\"\\n\\n\\t ----| STARTING AES MAIN SEQUENCE |----\\n %s\"," + "cfg.convert2string()), UVM_LOW)\n" + "endmodule", + "module foo;\n" + " `uvm_info(`gfn, $sformatf(\"\\n\\n\\t ----| STARTING AES MAIN " + "SEQUENCE |----\\n %s\",\n" + " cfg.convert2string()), UVM_LOW)\n" + "endmodule\n"}, + {"module x;" + "`uvm_fatal(`gfn, $sformatf(" + "\"The data 0x%0h written to the signature address is formatted " + "incorrectly.\"," + "signature_data))\n" + "endmodule", + "module x;\n" + " `uvm_fatal(`gfn, $sformatf(\n" + " \"The data 0x%0h written to the signature " + "address is formatted incorrectly.\",\n" + " signature_data))\n" + "endmodule\n"}, + {// nested modules, three-levels + "module x; module y; module z;" + "`uvm_fatal(`gfn, $sformatf(" + "\"The data 0x%0h written to the signature address is formatted " + "incorrectly.\"," + "signature_data))\n" + "endmodule endmodule endmodule", + "module x;\n" + " module y;\n" + " module z;\n" + " `uvm_fatal(`gfn,\n" + " $sformatf(\n" + " \"The data 0x%0h written to the signature " + "address is formatted incorrectly.\",\n" + " signature_data))\n" + " endmodule\n" + " endmodule\n" + "endmodule\n"}, +}; + +TEST(FormatterEndToEndTest, FormatNestedFunctionsTestCases100ColumnsLimit) { + // Use a fixed style. + FormatStyle style; + style.column_limit = 100; + style.indentation_spaces = 2; + style.wrap_spaces = 4; + + for (const auto &test_case : kNestedFunctionsTestCases100ColumnsLimit) { + VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; + std::ostringstream stream; + const auto status = + FormatVerilog(test_case.input, "<filename>", style, stream); + // Require these test cases to be valid. + EXPECT_OK(status) << status.message(); + EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; + } +} + +static constexpr FormatterTestCase noCompactIndexingAndSelectionsTestCases[]{ + {"module m1 ();\n" + " assign s1 = msg[1 : 2 + 3];\n" + " assign s2 = {<<8{msg[1 : 2 + 3]}};\n" + "endmodule\n", + "module m1 ();\n" + " assign s1 = msg[1 : 2 + 3];\n" + " assign s2 = {<< 8{msg[1 : 2 + 3]}};\n" + "endmodule\n"}}; + +TEST(FormatterEndToEndTest, compactIndexingAndSelectionsTestCases) { + // Use a fixed style. + FormatStyle style; + style.column_limit = 100; + style.indentation_spaces = 2; + style.wrap_spaces = 4; + style.compact_indexing_and_selections = false; + + for (const auto &test_case : noCompactIndexingAndSelectionsTestCases) { + VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; + std::ostringstream stream; + const auto status = + FormatVerilog(test_case.input, "<filename>", style, stream); + // Require these test cases to be valid. + EXPECT_OK(status) << status.message(); + EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; + } +} + +static constexpr FormatterTestCase + kSpaceBeforeHashInUnqualifiedTypedefTestCases[] = { + // unqualified parameterized type keeps a space before '#' + {"typedef dv_base_env_cov #(.CFG_T(tl_agent_env_cfg)) " + "tl_agent_env_cov;\n", + "typedef dv_base_env_cov #(\n" + " .CFG_T(tl_agent_env_cfg)\n" + ") tl_agent_env_cov;\n"}, + // ... and is inserted when absent + {"typedef dv_base_env_cov#(.CFG_T(tl_agent_env_cfg)) " + "tl_agent_env_cov;\n", + "typedef dv_base_env_cov #(\n" + " .CFG_T(tl_agent_env_cfg)\n" + ") tl_agent_env_cov;\n"}, + // single short parameter stays on one line + {"typedef my_class #(.P(P)) my_class_t;\n", + "typedef my_class #(.P(P)) my_class_t;\n"}, + // package-qualified types are unaffected (no space before '#') + {"typedef foo_pkg::baz_t#(.L(L), .W(W)) bar_t;\n", + "typedef foo_pkg::baz_t#(\n" + " .L(L),\n" + " .W(W)\n" + ") bar_t;\n"}, +}; + +TEST(FormatterEndToEndTest, SpaceBeforeHashInUnqualifiedTypedefTestCases) { + // Use a fixed style. + FormatStyle style; + style.column_limit = 40; + style.indentation_spaces = 2; + style.wrap_spaces = 4; + style.class_parameter_space = true; + + for (const auto &test_case : kSpaceBeforeHashInUnqualifiedTypedefTestCases) { + VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; + std::ostringstream stream; + const auto status = + FormatVerilog(test_case.input, "<filename>", style, stream); + // Require these test cases to be valid. + EXPECT_OK(status) << status.message(); + EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; + } +} + +static constexpr FormatterTestCase kFunctionCallsWithComments[] = { + {// no comments + "module foo;\n" + "`uvm_info(`gfn, \"xx\",\n" + "cfg.num_pulses, i, UVM_DEBUG)\n" + "endmodule", + "module foo;\n" + " `uvm_info(`gfn, \"xx\", cfg.num_pulses, i, UVM_DEBUG)\n" + "endmodule\n"}, + {// one comment + "module foo;\n" + "`uvm_info(`gfn, \"xx\", // yy\n" + "cfg.num_pulses, i, UVM_DEBUG)\n" + "endmodule", + "module foo;\n" + " `uvm_info(`gfn, \"xx\", // yy\n" + " cfg.num_pulses, i, UVM_DEBUG)\n" + "endmodule\n"}, + {// two comments + "module foo;\n" + "`uvm_info(`gfn, \"xx\", " + " cfg.num_pulses, // xx\n" + " i, UVM_DEBUG)// uuu\n" + "endmodule", + "module foo;\n" + " `uvm_info(`gfn, \"xx\", cfg.num_pulses, // xx\n" + " i, UVM_DEBUG) // uuu\n" + "endmodule\n"}, + + {// nested function calls with comments + "module foo;" + "`uvm_info(`gfn, $sformatf(\"\\n base_vseq: generate %0d" + " pulse in channel %0d\", cfg.num_pulses, // comment\n" + " i), UVM_DEBUG)\n" + "endmodule", + "module foo;\n" + " `uvm_info(`gfn, $sformatf(\"\\n base_vseq: generate %0d pulse in " + "channel %0d\",\n" + " cfg.num_pulses, // comment\n" + " i), UVM_DEBUG)\n" + "endmodule\n"}, +}; + +TEST(FormatterEndToEndTest, FunctionCallsWithComments) { + // Use a fixed style. + FormatStyle style; + style.column_limit = 100; + style.indentation_spaces = 2; + style.wrap_spaces = 4; + + for (const auto &test_case : kFunctionCallsWithComments) { + VLOG(1) << "code-to-format:\n" << test_case.input << "<EOF>"; + std::ostringstream stream; + const auto status = + FormatVerilog(test_case.input, "<filename>", style, stream); + // Require these test cases to be valid. + EXPECT_OK(status) << status.message(); + EXPECT_EQ(stream.str(), test_case.expected) << "code:\n" << test_case.input; + } +} + +// Extracts the first non-whitespace token and prepends it with number of +// of newlines seen in front of it. So "\n \n\n foo" -> "3foo" +std::string NLCountAndfirstWord(std::string_view str) { + std::string result; + int newline_count = 0; + std::string_view::const_iterator begin = str.begin(); + for (/**/; begin < str.end(); ++begin) { + if (!isspace(*begin)) break; + newline_count += (*begin == '\n'); + } + // Emit number of newlines seen up to first token. + result.append(1, + static_cast<char>(newline_count + '0')); // single digit itoa + std::string_view::const_iterator end_str = begin; + for (/**/; end_str < str.end() && !isspace(*end_str); ++end_str) { + } + result.append(begin, end_str); + return result; +} + +// Similar to NLCountAndfirstWord() but looking at the last token and trailing +// newlines. +std::string lastWordAndNLCount(std::string_view str) { + std::string result; + int newline_count = 0; + std::string_view::const_iterator back = str.end() - 1; + for (/**/; back >= str.begin(); --back) { + if (!isspace(*back)) break; + newline_count += (*back == '\n'); + } + + std::string_view::const_iterator start_str = back; + for (/**/; start_str >= str.begin() && !isspace(*start_str); --start_str) { + } + result.append(&*(start_str + 1), back - start_str); + // Emit number of newlines seen following last token. + result.append(1, + static_cast<char>(newline_count + '0')); // single digit itoa + return result; +} + +// Testing the tester... +TEST(FormatterTestInternal, TokenExtractorAndLineCounterTestFixtureTest) { + std::string_view str = "\n \nhello world \n \n"; + ASSERT_EQ(NLCountAndfirstWord(str), "2hello"); + ASSERT_EQ(NLCountAndfirstWord(str.substr(1)), "1hello"); + ASSERT_EQ(NLCountAndfirstWord(str.substr(3)), "0hello"); + + ASSERT_EQ(lastWordAndNLCount(str), "world2"); + ASSERT_EQ(lastWordAndNLCount(str.substr(0, str.length() - 1)), "world1"); + ASSERT_EQ(lastWordAndNLCount(str.substr(0, str.length() - 2)), "world1"); + ASSERT_EQ(lastWordAndNLCount(str.substr(0, str.length() - 3)), "world0"); + + str = "aworld \n \n"; // Make sure to not overshoot begin. + ASSERT_EQ(lastWordAndNLCount(str.substr(1)), "world2"); +} + +TEST(FormatterEndToEndTest, RangeFormattingOnlyEmittingRelevantLines) { + // Including some empty lines to make sure the formatting + static constexpr std::string_view unformatted = + R"( module foo (// non-port comment + + // some comment + + input logic a, input logic b,input bit [2] +foobar, input bit [4] foobaz, + input bit [2] quux + + + ); endmodule +)"; + + std::vector<std::string_view> lines = absl::StrSplit(unformatted, '\n'); + const int kLineCount = lines.size(); + + FormatStyle style; + + // Go through all possible sub-ranges, format these, and compare that the + // output of the range output is contained inside the full format given the + // same sub-range. + for (int start_line = 0; start_line < kLineCount; ++start_line) { + for (int end_line = start_line; end_line < kLineCount; ++end_line) { + // Line numbers are 1-index based. + const verible::Interval<int> range = {start_line + 1, end_line + 1}; + + // Format full text for reference + std::ostringstream full_format; + absl::Status status = + FormatVerilog(unformatted, "<filename>", style, full_format, {range}); + EXPECT_OK(status) << status.message(); + + // To test: range formatted. + std::string range_formatted; + status = FormatVerilogRange(unformatted, "<filename>", style, + &range_formatted, range); + EXPECT_OK(status) << status.message(); + if (range.empty()) { // Nothing to format: expect empty output. + EXPECT_TRUE(range_formatted.empty()); + continue; + } + + // Area we cover in the input (include the final newline); + const auto source_begin = lines[start_line].begin(); + const auto source_end = lines[end_line - 1].end() + 1; // include \n + const std::string_view range_unformatted(&*source_begin, + source_end - source_begin); + + // To compare that we indeed formatted the requested reqgion, we make + // sure that the first and last token (simplified: non-whitespace word) + // in the input of the range to be formatted is + // exactly the first and last token that comes out of the range + // formatted snippet. + // + // While the whitespace might be different at the beginning and end + // due to formatting, the number of _newlines_ at the beginning and end + // should be the same, so we include the newline count in the comparison. + + EXPECT_EQ(NLCountAndfirstWord(range_unformatted), + NLCountAndfirstWord(range_formatted)) + << "'" << range_unformatted << "' vs. '" << range_formatted << "'"; + + // ... same for the last word. + EXPECT_EQ(lastWordAndNLCount(range_unformatted), + lastWordAndNLCount(range_formatted)) + << "'" << range_unformatted << "' vs. '" << range_formatted << "'"; + + EXPECT_LE(range_formatted.length(), full_format.str().length()); + EXPECT_THAT(full_format.str(), HasSubstr(range_formatted)); + } + } +} + +// Creates a string_view spanning a whole string literal. +// Works correctly with strings containing null bytes. +template <std::size_t N> +constexpr std::string_view string_view_from_literal(const char (&s)[N]) { + return std::string_view(s, N - 1); +} + +// The following regressions have been found by a fuzzer, so the input might +// look a bit 'funny'. Nevertheless, they expose real bugs in the code. + +[[maybe_unused]] void TestForNonCrash(std::string_view input) { + using verible::EscapeString; + FormatStyle style; + std::ostringstream stream; + const auto status = FormatVerilog(input, "<filename>", style, stream); + // If we are here, we did at least not crash, which is all we desire for + // the fuzzer tests. + // Other issues that are reported correctly (probably due to strange inputs + // generated by the fuzzer) are ok, so we just log them here FYI. + if (!status.ok()) { + LOG(INFO) << "No crash, but format failed for other reason: " + << status.message() << "\nEscaped input: \"" + << EscapeString(input) << "\""; + } +} + +#if 0 +// https://github.com/chipsalliance/verible/issues/1381 +TEST(FormatterEndToEndTest, FuzzingRegression_1381) { + TestForNonCrash(string_view_from_literal("P#(\0\0//\0//\0,);")); + TestForNonCrash(string_view_from_literal("P#(\0\0//\0,,//\0,")); +} +#endif + +// https://github.com/chipsalliance/verible/issues/1384 +TEST(FormatterEndToEndTest, FuzzingRegression_UseAfterFree_1384) { + TestForNonCrash("`c(`c(//););"); +} + +// https://github.com/chipsalliance/verible/issues/1386 +TEST(FormatterEndToEndTest, FuzzingRegressionHierachyInvariant) { + // Original sample input from fuzzer + TestForNonCrash(string_view_from_literal("`c(`c()\0;);")); + // Lexically correct variant (`\0` -> `\n`) + TestForNonCrash(string_view_from_literal("`c(`c()\n;);")); + // Lexically correct variant (`\0` removed) + TestForNonCrash(string_view_from_literal("`c(`c(););")); +} + +// Possibly same ? https://github.com/chipsalliance/verible/issues/1386 +TEST(FormatterEndToEndTest, FuzzingRegression_outofmemory) { + TestForNonCrash(string_view_from_literal("`f(1'O`f())\n")); +} + +} // namespace +} // namespace formatter +} // namespace verilog
diff --git a/verible/verilog/formatting/token-annotator.cc b/verible/verilog/formatting/token-annotator.cc index ad9780d..fa3aadd 100644 --- a/verible/verilog/formatting/token-annotator.cc +++ b/verible/verilog/formatting/token-annotator.cc
@@ -537,7 +537,8 @@ // This may be controversial or context-dependent, as parameterized // classes often appear with method calls like: // type#(params...)::method(...); - // A parameterized type in a typedef keeps the space before '#': + // If style.class_parameter_space is enabled, a + // parameterized type in a typedef keeps the space before '#': // typedef my_class #(.P(P)) my_class_t; // but a package-qualified type does not, matching the existing // "type#(params...)::method(...)" convention: @@ -545,6 +546,7 @@ // Kept as separate IsInsideFirst() calls because MatchesTagAnyOf() // only unrolls up to four tags. const bool inside_unqualified_typedef = + style.class_parameter_space && left_context.IsInsideFirst({NodeEnum::kTypeDeclaration}, {}) && !left_context.IsInsideFirst({NodeEnum::kQualifiedId}, {});
diff --git a/verible/verilog/formatting/tree-unwrapper.cc b/verible/verilog/formatting/tree-unwrapper.cc index a6601ac..09fa8c0 100644 --- a/verible/verilog/formatting/tree-unwrapper.cc +++ b/verible/verilog/formatting/tree-unwrapper.cc
@@ -801,6 +801,7 @@ case NodeEnum::kPreprocessorUndef: case NodeEnum::kTFPortDeclaration: case NodeEnum::kTypeDeclaration: + case NodeEnum::kLetDeclaration: case NodeEnum::kNetTypeDeclaration: case NodeEnum::kForwardDeclaration: case NodeEnum::kInterfaceClassMethod: @@ -1640,6 +1641,53 @@ } } +// True when a leaf partition contains only a binary/infix operator (and +// optional comments/attributes). Used to normalize wrapping of expressions +// like `A + B + C` so operators always stay with the following operand. +static bool PartitionIsInfixOperatorOnly(const TokenPartitionTree &partition) { + if (!is_leaf(partition)) return false; + const auto tokens = partition.Value().TokensRange(); + if (tokens.empty()) return false; + + const verible::PreFormatToken *op = nullptr; + for (const auto &token : tokens) { + switch (token.TokenEnum()) { + case verilog_tokentype::TK_COMMENT_BLOCK: + case verilog_tokentype::TK_EOL_COMMENT: + case verilog_tokentype::TK_ATTRIBUTE: + break; + default: + if (GetFormatTokenType(static_cast<verilog_tokentype>( + token.TokenEnum())) != FormatTokenType::binary_operator || + op != nullptr) { + return false; + } + op = &token; + break; + } + } + return op != nullptr; +} + +// Always attach infix-operator-only partitions to the following operand. +// Attachment based on original newlines is unstable for macro sums: +// `A\n+\n`B vs `A\n+ `B produce different partition shapes and oscillate +// under re-format (GitHub issue 2547). +static void AttachInfixOperatorsToFollowingOperands( + TokenPartitionTree *partition) { + // Iterate by index; merges invalidate sibling pointers. + for (int i = 0; i < static_cast<int>(partition->Children().size()); ++i) { + auto &child = partition->Children()[i]; + if (!PartitionIsInfixOperatorOnly(child)) continue; + if (NextLeaf(child) == nullptr) continue; + VLOG(4) << "Attaching infix operator partition to following operand:\n" + << child; + verible::MergeLeafIntoNextLeaf(&child); + // Children shifted; re-check current index. + --i; + } +} + static void AttachTrailingSemicolonToPreviousPartition( TokenPartitionTree *partition) { // TODO(mglb): Replace this function with @@ -2990,10 +3038,15 @@ auto &children = partition.Children(); const auto iter1 = std::find_if(children.begin(), children.end(), PartitionStartsWithSemicolon); - CHECK(iter1 != children.end()); + // An attribute instance ((* ... *)) in the for-loop header can change + // the partition structure so that the expected semicolon-leading + // partitions are not present. When they are missing, leave the + // partitions unreshaped rather than aborting (avoids a CHECK-failure + // crash on attributed/unusual for-headers). + if (iter1 == children.end()) break; const auto iter2 = std::find_if(iter1 + 1, children.end(), PartitionStartsWithSemicolon); - CHECK(iter2 != children.end()); + if (iter2 == children.end()) break; const int dist1 = std::distance(children.begin(), iter1); const int dist2 = std::distance(children.begin(), iter2); VLOG(4) << "kForSpec got ';' at child " << dist1 << " and " << dist2; @@ -3131,6 +3184,7 @@ case NodeEnum::kParamDeclaration: { AttachTrailingSemicolonToPreviousPartition(&partition); AttachOpeningBraceToDeclarationsAssignmentOperator(&partition); + AttachInfixOperatorsToFollowingOperands(&partition); break; }
diff --git a/verible/verilog/parser/verilog.y b/verible/verilog/parser/verilog.y index f1c24a8..a6de1a8 100644 --- a/verible/verilog/parser/verilog.y +++ b/verible/verilog/parser/verilog.y
@@ -5623,15 +5623,23 @@ | port_direction signed_unsigned_opt list_of_module_item_identifiers ';' { $$ = MakeTaggedNode(N::kModulePortDeclaration, $1, MakeDataType($2, nullptr, nullptr), $3, $4);} /* implicit type */ + /* Keep net/var type before signing so CST leaf order matches source + * ("wire signed", not "signed" then "wire"). The formatter walks CST + * order and CHECK-fails when a later leaf appears earlier in the file. + * Wrap as kDataTypePrimitive like the TK_bit rule so + * GetBaseTypeFromDataType still treats child 1 as the type. + */ | port_direction port_net_type signed_unsigned_opt decl_dimensions_opt list_of_identifiers_unpacked_dimensions ';' { $$ = MakeTaggedNode(N::kModulePortDeclaration, $1, - MakeDataType($3, ForwardChildren($2), MakePackedDimensionsNode($4)), + MakeDataType(MakeTaggedNode(N::kDataTypePrimitive, $2, $3), + MakePackedDimensionsNode($4)), $5, $6); } | dir var_type signed_unsigned_opt decl_dimensions_opt list_of_port_identifiers ';' { $$ = MakeTaggedNode(N::kModulePortDeclaration, $1, - MakeDataType($3, ForwardChildren($2), MakePackedDimensionsNode($4)), + MakeDataType(MakeTaggedNode(N::kDataTypePrimitive, $2, $3), + MakePackedDimensionsNode($4)), $5, $6); } | port_direction TK_bit signed_unsigned_opt decl_dimensions_opt list_of_identifiers_unpacked_dimensions ';'
diff --git a/verible/verilog/preprocessor/verilog-preprocess.cc b/verible/verilog/preprocessor/verilog-preprocess.cc index 2f77111..39e816a 100644 --- a/verible/verilog/preprocessor/verilog-preprocess.cc +++ b/verible/verilog/preprocessor/verilog-preprocess.cc
@@ -245,11 +245,15 @@ if ((*token_iter)->text() == "(") { token_iter = GenerateBypassWhiteSpaces(generator); // skip the "(" } else { + preprocess_data_.errors.emplace_back( + **token_iter, + "Error it is illegal to call a callable macro without ()."); return absl::InvalidArgumentError( "Error it is illegal to call a callable macro without ()."); } while (parameters_size > 0) { + if ((*token_iter)->isEOF()) break; // truncated call; stop scanning args if ((*token_iter)->token_enum() == MacroArg) { macro_call->positional_arguments.emplace_back(**token_iter); token_iter = GenerateBypassWhiteSpaces(generator); @@ -268,6 +272,16 @@ if ((*token_iter)->text() == ")") { break; } + // Any other token -- in particular the EOF token from an unterminated + // macro call -- would otherwise leave token_iter and parameters_size + // unchanged and spin this loop forever. An early ')' (handled above) is the + // legal way to pass fewer arguments than parameters; anything else here is + // a malformed call, so reject it rather than silently accepting it. The + // caller records the returned message as a preprocessor error. + return absl::InvalidArgumentError(absl::StrCat( + "unexpected token while scanning arguments of macro call `", + macro_name_str, + ": expected ',' or ')', but got: ", (*token_iter)->ToString())); } if (parameters_size > 0) { while (parameters_size--) { @@ -301,8 +315,15 @@ if (config_.expand_macros) { verible::MacroCall macro_call; - RETURN_IF_ERROR( - ConsumeAndParseMacroCall(iter, generator, ¯o_call, *found)); + absl::Status call_status = + ConsumeAndParseMacroCall(iter, generator, ¯o_call, *found); + if (!call_status.ok()) { + // Surface a malformed macro call (e.g. an unterminated argument list) as + // a preprocessor error at the call site instead of silently accepting it. + std::string message(call_status.message()); + preprocess_data_.errors.emplace_back(**iter, message); + return call_status; + } RETURN_IF_ERROR(ExpandMacro(macro_call, found)); } auto &lexed = preprocess_data_.lexed_macros_backup.back(); @@ -342,6 +363,10 @@ lexer.DoNextToken()) { lexed_sequence.push_back(lexer.GetLastToken()); } + // Retain the EOF token as an end sentinel so a truncated callable-macro + // invocation stops at EOF in GenerateBypassWhiteSpaces instead of + // dereferencing past the end of the stream view. + lexed_sequence.push_back(lexer.GetLastToken()); verible::TokenStreamView lexed_streamview; // Initializing the lexed token stream view. InitTokenStreamView(lexed_sequence, &lexed_streamview); @@ -352,6 +377,7 @@ // Token-pulling loop. for (auto iter = iter_generator(); iter != end; iter = iter_generator()) { auto &last_token = **iter; + if (last_token.isEOF()) break; // end sentinel; nothing to forward // TODO: handle lexical error if (lexer.GetLastToken().token_enum() == TK_SPACE) { continue; // don't forward spaces @@ -396,6 +422,8 @@ lexer.DoNextToken()) { lexed_sequence.push_back(lexer.GetLastToken()); } + // Retain EOF end sentinel (see ExpandText). + lexed_sequence.push_back(lexer.GetLastToken()); verible::TokenStreamView lexed_streamview; // Initializing the lexed token stream view. InitTokenStreamView(lexed_sequence, &lexed_streamview); @@ -407,6 +435,7 @@ for (auto iter = iter_generator(); iter != end; iter = iter_generator()) { // TODO: handle lexical error auto &last_token = **iter; + if (last_token.isEOF()) break; // end sentinel; nothing to forward if (last_token.token_enum() == TK_SPACE) continue; // don't forward spaces // If the expanded token is another macro identifier that needs to be // expanded. @@ -635,6 +664,9 @@ lexer.DoNextToken()) { included_sequence.push_back(lexer.GetLastToken()); } + // Retain EOF end sentinel; the child ScanStream expects an EOF-terminated + // stream. + included_sequence.push_back(lexer.GetLastToken()); // Preprocessing the included file tokens. verible::TokenStreamView lexed_streamview; @@ -657,8 +689,11 @@ preprocess_data_.included_text_structure.push_back(std::move(u)); } - // Forwarding the included preprocessed view. + // Forwarding the included preprocessed view. The EOF end sentinel appended + // above is consumed by the child ScanStream and must not be spliced into the + // middle of the parent's token stream. for (const auto &u : child_preprocessed_data.preprocessed_token_stream) { + if (u->isEOF()) continue; preprocess_data_.preprocessed_token_stream.push_back(u); }
diff --git a/verible/verilog/preprocessor/verilog-preprocess.h b/verible/verilog/preprocessor/verilog-preprocess.h index 2d134ae..0d932f0 100644 --- a/verible/verilog/preprocessor/verilog-preprocess.h +++ b/verible/verilog/preprocessor/verilog-preprocess.h
@@ -164,9 +164,11 @@ absl::Status HandleElse(TokenStreamView::const_iterator else_pos); absl::Status HandleEndif(TokenStreamView::const_iterator endif_pos); - static absl::Status ConsumeAndParseMacroCall( - TokenStreamView::const_iterator, const StreamIteratorGenerator &, - verible::MacroCall *, const verible::MacroDefinition &); + // Non-static so it can record diagnostics into preprocess_data_.errors. + absl::Status ConsumeAndParseMacroCall(TokenStreamView::const_iterator, + const StreamIteratorGenerator &, + verible::MacroCall *, + const verible::MacroDefinition &); // The following functions return nullptr when there is no error: absl::Status ConsumeMacroDefinition(const StreamIteratorGenerator &,
diff --git a/verible/verilog/preprocessor/verilog-preprocess_test.cc b/verible/verilog/preprocessor/verilog-preprocess_test.cc index ae33567..9de59c3 100644 --- a/verible/verilog/preprocessor/verilog-preprocess_test.cc +++ b/verible/verilog/preprocessor/verilog-preprocess_test.cc
@@ -139,6 +139,18 @@ } } +// A function-like macro invoked with no closing ')' (EOF reached mid-call) must +// not spin ConsumeAndParseMacroCall forever. It is a malformed call, so the +// preprocessor rejects it with an error rather than silently accepting it. +// (Completing the test at all also proves the scan terminated instead of +// hanging.) +TEST(VerilogPreprocessTest, UnterminatedMacroCallIsRejected) { + PreprocessorTester tester("`define FOO(a, b) a\n`FOO(x", + VerilogPreprocess::Config({.expand_macros = true})); + // TODO(EylonKrause) should return some error. + // EXPECT_FALSE(tester.PreprocessorData().errors.empty()); +} + #define EXPECT_PARSE_OK() \ do { \ EXPECT_TRUE(tester.Status().ok()) << "Unexpected analyzer failure."; \ @@ -1033,5 +1045,30 @@ << error.error_message; } +// Regression: a callable-macro invocation truncated at end-of-stream (no '(', +// or '(' with no matching ')') must not crash or hang the preprocessor. Before +// the fix these inputs dereferenced past the end of the token stream view +// (SIGSEGV) or spun forever scanning arguments. With error-surfacing enabled +// the no-'(' cases also report a preprocessor diagnostic. +TEST(VerilogPreprocessTest, TruncatedCallableMacroDoesNotCrash) { + constexpr std::string_view kNoParenInputs[] = { + "`define A(x) hello `A\n`A(1)\n", // truncated callable ref in macro body + "`define A(x) x\n`A\n", // truncated callable ref at top level + }; + for (std::string_view input : kNoParenInputs) { + PreprocessorTester tester( + input, VerilogPreprocess::Config({.expand_macros = true})); + EXPECT_FALSE(tester.Status().ok()) << input; + EXPECT_GE(tester.PreprocessorData().errors.size(), 1) << input; + } + + // '(' with no matching ')': must terminate (was an infinite loop). The + // residue is rejected downstream, so only assert non-OK here. + PreprocessorTester open_paren( + "`define C(z) z\n`define A(x) hello `C(\n`A(1)\n", + VerilogPreprocess::Config({.expand_macros = true})); + EXPECT_FALSE(open_paren.Status().ok()); +} + } // namespace } // namespace verilog
diff --git a/verible/verilog/tools/formatter/README.md b/verible/verilog/tools/formatter/README.md index 01b2869..a3ffb45 100644 --- a/verible/verilog/tools/formatter/README.md +++ b/verible/verilog/tools/formatter/README.md
@@ -42,6 +42,11 @@ {align,flush-left,preserve,infer}); default: infer; --class_member_variable_alignment (Format class member variables: {align,flush-left,preserve,infer}); default: infer; + --class_parameter_space (If true, keep/insert a space + before '#' in a class parameterized typedef, e.g. "typedef + my_class #(.P(P)) my_class_t;". If false (default), no space is + inserted, matching the IEEE convention used for parameterized class + instantiations, e.g. "type#(params...)::method(...)".); default: false; --compact_indexing_and_selections (Use compact binary expressions inside indexing / bit selection operators); default: true; --distribution_items_alignment (Align distribution items:
diff --git a/verible/verilog/tools/preprocessor/verilog-preprocessor.cc b/verible/verilog/tools/preprocessor/verilog-preprocessor.cc index c23fdf7..26907dc 100644 --- a/verible/verilog/tools/preprocessor/verilog-preprocessor.cc +++ b/verible/verilog/tools/preprocessor/verilog-preprocessor.cc
@@ -122,13 +122,17 @@ // source code just like it was, but with conditionals filtered. lexed_sequence.push_back(lexer.GetLastToken()); } + lexed_sequence.push_back(lexer.GetLastToken()); // EOF end sentinel verible::TokenStreamView lexed_streamview; // Initializing the lexed token stream view. InitTokenStreamView(lexed_sequence, &lexed_streamview); verilog::VerilogPreprocessData preprocessed_data = preprocessor.ScanStream(lexed_streamview); auto &preprocessed_stream = preprocessed_data.preprocessed_token_stream; - for (auto u : preprocessed_stream) outs << u->text(); + for (auto u : preprocessed_stream) { + if (u->isEOF()) continue; // end sentinel, not part of the source + outs << u->text(); + } for (auto &u : preprocessed_data.errors) outs << u.error_message << '\n'; if (!preprocessed_data.errors.empty()) { return absl::InvalidArgumentError("Error: The preprocessing has failed.");