From a1721e4cfe7290807a854ed42beb4139eeaad63e Mon Sep 17 00:00:00 2001 From: abacus_fixer Date: Thu, 20 Aug 2026 22:27:49 +0800 Subject: [PATCH 01/27] add a python script to check the code quality --- tools/03_code_analysis/code_quality_score.py | 704 +++++++++++++++++++ 1 file changed, 704 insertions(+) create mode 100644 tools/03_code_analysis/code_quality_score.py diff --git a/tools/03_code_analysis/code_quality_score.py b/tools/03_code_analysis/code_quality_score.py new file mode 100644 index 00000000000..69e71f71f7e --- /dev/null +++ b/tools/03_code_analysis/code_quality_score.py @@ -0,0 +1,704 @@ +#!/usr/bin/env python3 +"""ABACUS code quality scoring tool. + +Scans source files/directories and assigns each file a quality score +starting from 100, deducting points for each rule violation found. + +Rules (per-file score starts at 100): + Core rules: + - filename stem longer than 20 chars: -1 + - filename contains uppercase letters: -1 + - filename extension is .hpp: -50 + - each public member variable in a class/struct: -1 + - member function longer than 50 lines: -1 per additional 50-line block + Zero-cost rules (no C++ parsing needed): + - tab indentation: -1 per line (cap 5) + - `using namespace std;`: -1 per occurrence (cap 5) + - line longer than 120 chars: -1 per line (cap 5) + - Chinese characters in comments/code: -1 per line (cap 5) + - UPPERCASE constant naming (>3 chars all caps): -1 per occurrence (cap 5) + Interface & dependency rules: + - function declaration with default parameter: -2 per occurrence (cap 5) + - GlobalV::/GlobalC::/PARAM.* cross-layer dependency: -3 per occurrence (cap 10) + - #include of .hpp implementation header: -2 per occurrence (cap 5) + - `friend` keyword exposing internals: -1 per occurrence (cap 5) + - unpaired `new` without matching `delete`: -1 per occurrence (cap 5) + - local variable shadowing a member variable: -1 per occurrence (cap 5) + +Usage: + python3 code_quality_score.py source/source_base + # writes report to ./code_quality_score.txt (text default output file) + python3 code_quality_score.py source/ -o report.txt + python3 code_quality_score.py --format json path/to/file.cpp + python3 code_quality_score.py --format json source/ -o report.json + python3 code_quality_score.py --min-score 80 source/ +""" + +from __future__ import annotations + +import argparse +import json +import re +import sys +from dataclasses import dataclass, field +from pathlib import Path +from typing import List, Optional, Sequence, Tuple + + +SOURCE_EXTENSIONS = {".c", ".cc", ".cpp", ".cxx", ".cu", ".h", ".hh", ".hpp", ".hxx", ".cuh"} + +SKIP_DIRS = { + ".git", "build", "__pycache__", "node_modules", ".cache", + "third_party", "thirdparty", ".vscode", ".idea", ".trae-cn", + "Dependencies", +} + +CAPS = { + "tab_indentation": 5, + "using_namespace_std": 5, + "line_too_long": 5, + "chinese_comment": 5, + "uppercase_constant": 5, + "default_parameter": 5, + "global_dependency": 10, + "hpp_include": 5, + "friend_keyword": 5, + "unpaired_new_delete": 5, + "member_local_name_conflict": 5, +} + +WEIGHTS = { + "filename_too_long": 1, + "filename_uppercase": 1, + "hpp_implementation": 50, + "public_member_variable": 1, + "member_function_too_long": 1, + "tab_indentation": 1, + "using_namespace_std": 1, + "line_too_long": 1, + "chinese_comment": 1, + "uppercase_constant": 1, + "default_parameter": 2, + "global_dependency": 3, + "hpp_include": 2, + "friend_keyword": 1, + "unpaired_new_delete": 1, + "member_local_name_conflict": 1, +} + +FUNCTION_LENGTH_THRESHOLD = 50 +FUNCTION_LENGTH_STEP = 50 +LINE_LENGTH_LIMIT = 120 +FILENAME_LENGTH_LIMIT = 20 +PASS_THRESHOLD = 60 + +CHINESE_RE = re.compile("[\u4e00-\u9fff]") +USING_NS_STD_RE = re.compile(r"\busing\s+namespace\s+std\b") +UPPERCASE_CONST_RE = re.compile(r"\b[A-Z][A-Z0-9_]{2,}\b") +ACCESS_RE = re.compile(r"^\s*(public|private|protected)\s*:") +CLASS_OPEN_RE = re.compile(r"\b(class|struct)\s+(\w+)\b") + +GLOBAL_DEPENDENCY_RE = re.compile(r"\b(?:GlobalV::|GlobalC::|PARAM(?:\.|->|::))") +HPP_INCLUDE_RE = re.compile(r'^\s*#\s*include\s+[<"][^>"]+\.hpp[>"]') +FRIEND_RE = re.compile(r"\bfriend\b") +NEW_EXPR_RE = re.compile(r"\bnew\s+\w") +DELETE_EXPR_RE = re.compile(r"\bdelete\s*\[\s*\]?\s+\w") + +DEFAULT_PARAM_RE = re.compile( + r"\b\w+\s*\([^();]*\b\w+\s*=(?![=>])[^();]*\)\s*" + r"(?:const\s*|noexcept\s*|override\s*|final\s*)*[;{]" +) + +# Strict declaration regex: requires `type ... name ;` or `type ... name = ...;`. +# Excludes pure assignments like `counter = counter + 1;` which lack a leading type. +DECL_RE = re.compile(r"^\s*(?:\w+[\s\*]+)+(\w+)\s*(?:=[^;]*)?;\s*$") + +BLOCK_KEYWORD_PREFIXES = ( + "public:", "private:", "protected:", + "typedef", "using", "static_assert", + "class", "struct", "friend", + "//", "/*", "*", + "return", "if ", "for ", "while ", + "switch ", "case ", "template", + "break", "continue", "goto", "default:", + "else", "do", "try", "catch", "throw", + "namespace", "enum", "union", +) + + +@dataclass +class Finding: + rule: str + line: Optional[int] + reason: str + deduction: int + + +@dataclass +class FileReport: + path: str + score: int + findings: List[Finding] = field(default_factory=list) + + def to_dict(self) -> dict: + return { + "path": self.path, + "score": self.score, + "findings": [ + { + "rule": f.rule, + "line": f.line, + "reason": f.reason, + "deduction": f.deduction, + } + for f in self.findings + ], + } + + +def discover_files(paths: Sequence[str]) -> List[Path]: + """Walk input paths and return source files, skipping generated dirs.""" + result: List[Path] = [] + for p in paths: + path = Path(p) + if path.is_file(): + if path.suffix in SOURCE_EXTENSIONS: + result.append(path) + elif path.is_dir(): + for sub in path.rglob("*"): + if not sub.is_file(): + continue + if any(part in SKIP_DIRS for part in sub.parts): + continue + if sub.suffix in SOURCE_EXTENSIONS: + result.append(sub) + return result + + +def strip_comments(content: str) -> str: + """Return content with comments replaced by spaces, preserving line numbers. + + Handles // line comments and /* */ block comments. String literals are + respected so that '/' inside strings is not mistaken for a comment. + """ + out = [] + i = 0 + n = len(content) + in_string = False + in_char = False + while i < n: + c = content[i] + if in_string: + out.append(c) + if c == "\\" and i + 1 < n: + out.append(content[i + 1]) + i += 2 + continue + if c == '"': + in_string = False + i += 1 + continue + if in_char: + out.append(c) + if c == "\\" and i + 1 < n: + out.append(content[i + 1]) + i += 2 + continue + if c == "'": + in_char = False + i += 1 + continue + if c == '"': + in_string = True + out.append(c) + i += 1 + continue + if c == "'": + in_char = True + out.append(c) + i += 1 + continue + if c == "/" and i + 1 < n: + if content[i + 1] == "/": + # line comment until newline + j = content.find("\n", i) + if j < 0: + j = n + out.append(" " * (j - i)) + i = j + continue + if content[i + 1] == "*": + # block comment until */ + j = content.find("*/", i + 2) + if j < 0: + j = n + else: + j += 2 + block = content[i:j] + # preserve newlines + out.append(re.sub(r"[^\n]", " ", block)) + i = j + continue + out.append(c) + i += 1 + return "".join(out) + + +def find_class_blocks(code: str) -> List[Tuple[int, int, str, str]]: + """Find top-level class/struct blocks. Returns list of + (start_line_1indexed, end_line_1indexed, kind, name). + + Walks brace matching starting from each `class X {` / `struct X {` opener. + """ + blocks: List[Tuple[int, int, str, str]] = [] + i = 0 + n = len(code) + while i < n: + m = CLASS_OPEN_RE.search(code, i) + if not m: + break + # find the opening brace after the class/struct header + # allow inheritance clauses: class X : public Y { ... } + brace_pos = code.find("{", m.end()) + if brace_pos < 0: + break + # reject if there's a `;` before the brace (forward declaration) + if ";" in code[m.end():brace_pos]: + i = m.end() + continue + depth = 1 + j = brace_pos + 1 + in_string = False + in_char = False + while j < n and depth > 0: + c = code[j] + if in_string: + if c == "\\": + j += 2 + continue + if c == '"': + in_string = False + j += 1 + continue + if in_char: + if c == "\\": + j += 2 + continue + if c == "'": + in_char = False + j += 1 + continue + if c == '"': + in_string = True + j += 1 + continue + if c == "'": + in_char = True + j += 1 + continue + if c == "{": + depth += 1 + elif c == "}": + depth -= 1 + if depth == 0: + break + j += 1 + if depth == 0: + start_line = code[:m.start()].count("\n") + 1 + end_line = code[:j].count("\n") + 1 + blocks.append((start_line, end_line, m.group(1), m.group(2))) + i = j + 1 + else: + i = m.end() + return blocks + + +def detect_access_at_line(class_lines: List[str], target_idx: int, default_access: str) -> str: + """Determine the active access specifier for line `target_idx` inside class.""" + access = default_access + for k in range(target_idx + 1): + m = ACCESS_RE.match(class_lines[k]) + if m: + access = m.group(1) + return access + + +def is_public_member_var(line: str) -> bool: + """Heuristic: does this stripped code line look like a public member variable + declaration (not a function, not a typedef, not a nested class)?""" + s = line.strip() + if not s.endswith(";"): + return False + if "(" in s or ")" in s: + return False + if "{" in s or "}" in s: + return False + if "=" in s and "(" in s: + return False + bad_prefixes = ( + "public:", "private:", "protected:", + "typedef", "using", "static_assert", + "class", "struct", "friend", + "//", "/*", "*", + "return", "if ", "for ", "while ", "switch ", "case ", + "template", + ) + if s.startswith(bad_prefixes): + return False + # skip macro-like lines (all caps with parens already excluded above) + # require at least one identifier character + if not re.search(r"[A-Za-z_]", s): + return False + return True + + +def _match_var_decl(stripped_line: str) -> Optional[str]: + """If line looks like a variable declaration `type name;` or + `type name = ...;`, return the variable name; else None. + + Excludes pure assignments (e.g. `counter = counter + 1;`) which lack a + leading type token. This is a best-effort heuristic, not a full parser. + """ + s = stripped_line.strip() + if not s or s.startswith(BLOCK_KEYWORD_PREFIXES): + return None + m = DECL_RE.match(s) + return m.group(1) if m else None + + +def analyze_class_blocks(content: str) -> Tuple[List[Finding], List[Finding], List[Finding]]: + """Analyze class/struct blocks for public member variables, long member + functions, and member/local name conflicts. + + Returns (public_member_findings, long_function_findings, name_conflict_findings). + """ + pub_findings: List[Finding] = [] + long_func_findings: List[Finding] = [] + conflict_findings: List[Finding] = [] + + stripped = strip_comments(content) + lines = stripped.split("\n") + + for start_line, end_line, kind, name in find_class_blocks(stripped): + default_access = "private" if kind == "class" else "public" + body_start = start_line - 1 + body_end = end_line - 1 + class_lines = lines[body_start:body_end + 1] + + # pre-compute access per line (for public member variable rule) + access_per_line: List[str] = [] + cur_access = default_access + for k in range(len(class_lines)): + m = ACCESS_RE.match(class_lines[k]) + if m: + cur_access = m.group(1) + access_per_line.append(cur_access) + + # pass 1: collect all member variable names (any access section). + # depth starts at 0; the class header line brings it to 1. Only lines + # that begin AND end at depth 1 are class-body member declarations + # (lines that open a function body bring depth from 1 to 2). + member_var_names: set = set() + depth = 0 + for line in class_lines: + prev_depth = depth + depth += line.count("{") - line.count("}") + if prev_depth == 1 and depth == 1: + var_name = _match_var_decl(line) + if var_name: + member_var_names.add(var_name) + + # pass 2: walk class body for findings + depth = 0 + func_start_abs = -1 + for idx in range(len(class_lines)): + line = class_lines[idx] + abs_line = body_start + idx + 1 # 1-indexed absolute line + prev_depth = depth + + # public member variable: only at depth 1 (class body, not in a function) + if prev_depth == 1 and access_per_line[idx] == "public": + if is_public_member_var(line): + pub_findings.append(Finding( + rule="public_member_variable", + line=abs_line, + reason=f"public member in {kind} {name}: {line.strip()}", + deduction=WEIGHTS["public_member_variable"], + )) + + # member/local name conflict: only at depth >= 2 (function body) + if prev_depth >= 2: + var_name = _match_var_decl(line) + if var_name and var_name in member_var_names: + conflict_findings.append(Finding( + rule="member_local_name_conflict", + line=abs_line, + reason=( + f"local variable '{var_name}' in {kind} {name} " + f"shadows a member variable" + ), + deduction=WEIGHTS["member_local_name_conflict"], + )) + + # apply brace counting for this line + depth = prev_depth + line.count("{") - line.count("}") + + # function body start: transition from depth 1 to >=2 + if prev_depth == 1 and depth >= 2 and func_start_abs < 0: + func_start_abs = abs_line + # function body end: transition from >=2 back to 1 + if prev_depth >= 2 and depth == 1 and func_start_abs > 0: + func_end_abs = abs_line + func_lines = func_end_abs - func_start_abs + 1 + if func_lines > FUNCTION_LENGTH_THRESHOLD: + excess = func_lines - FUNCTION_LENGTH_THRESHOLD + blocks = (excess + FUNCTION_LENGTH_STEP - 1) // FUNCTION_LENGTH_STEP + long_func_findings.append(Finding( + rule="member_function_too_long", + line=func_start_abs, + reason=( + f"member function in {kind} {name} spans {func_lines} lines " + f"(exceeds {FUNCTION_LENGTH_THRESHOLD})" + ), + deduction=blocks * WEIGHTS["member_function_too_long"], + )) + func_start_abs = -1 + + return pub_findings, long_func_findings, conflict_findings + + +def analyze_file(path: Path) -> FileReport: + """Analyze one file and return its FileReport.""" + findings: List[Finding] = [] + name = path.name + stem = path.stem + suffix = path.suffix + + # filename rules + if len(stem) > FILENAME_LENGTH_LIMIT: + findings.append(Finding( + rule="filename_too_long", + line=None, + reason=( + f"filename '{name}' stem has {len(stem)} chars " + f"(limit {FILENAME_LENGTH_LIMIT})" + ), + deduction=WEIGHTS["filename_too_long"], + )) + if any(c.isupper() for c in stem): + findings.append(Finding( + rule="filename_uppercase", + line=None, + reason=f"filename '{name}' contains uppercase letters", + deduction=WEIGHTS["filename_uppercase"], + )) + if suffix == ".hpp": + findings.append(Finding( + rule="hpp_implementation", + line=None, + reason=".hpp implementation header prohibited (use .cpp + .h split)", + deduction=WEIGHTS["hpp_implementation"], + )) + + # read content + try: + content = path.read_text(encoding="utf-8", errors="replace") + except OSError as e: + findings.append(Finding( + rule="read_error", + line=None, + reason=f"failed to read file: {e}", + deduction=0, + )) + return FileReport(path=str(path), score=100, findings=findings) + + lines = content.split("\n") + + # line-based rules with caps + tab_count = sum(1 for l in lines if "\t" in l) + long_line_count = sum(1 for l in lines if len(l) > LINE_LENGTH_LIMIT) + using_ns_count = sum( + 1 for l in lines if USING_NS_STD_RE.search(strip_comments(l)) + ) + chinese_count = sum(1 for l in lines if CHINESE_RE.search(l)) + + stripped_content = strip_comments(content) + upper_const_count = 0 + for l in stripped_content.split("\n"): + upper_const_count += len(UPPERCASE_CONST_RE.findall(l)) + + # interface & dependency rules + global_dep_count = len(GLOBAL_DEPENDENCY_RE.findall(stripped_content)) + hpp_include_count = sum(1 for l in lines if HPP_INCLUDE_RE.match(l)) + friend_count = len(FRIEND_RE.findall(stripped_content)) + + # default parameter: scan each stripped line for function-decl signature + default_param_count = 0 + for l in stripped_content.split("\n"): + default_param_count += len(DEFAULT_PARAM_RE.findall(l)) + + # unpaired new/delete (file-level): rough heuristic, cap applied below + new_count = len(NEW_EXPR_RE.findall(stripped_content)) + delete_count = len(DELETE_EXPR_RE.findall(stripped_content)) + unpaired_new = max(0, new_count - delete_count) + + def append_capped(rule: str, count: int) -> None: + if count == 0: + return + cap = CAPS.get(rule) + actual = min(count, cap) if cap else count + cap_text = f" (capped at {cap})" if cap and count > cap else "" + findings.append(Finding( + rule=rule, + line=None, + reason=f"{count} occurrence(s){cap_text}", + deduction=actual * WEIGHTS[rule], + )) + + append_capped("tab_indentation", tab_count) + append_capped("line_too_long", long_line_count) + append_capped("using_namespace_std", using_ns_count) + append_capped("chinese_comment", chinese_count) + append_capped("uppercase_constant", upper_const_count) + append_capped("default_parameter", default_param_count) + append_capped("global_dependency", global_dep_count) + append_capped("hpp_include", hpp_include_count) + append_capped("friend_keyword", friend_count) + append_capped("unpaired_new_delete", unpaired_new) + + # class-based rules + pub_findings, long_func_findings, conflict_findings = analyze_class_blocks(content) + findings.extend(pub_findings) + findings.extend(long_func_findings) + # name conflict findings already respect cap via per-file cap on the rule + if len(conflict_findings) > CAPS.get("member_local_name_conflict", len(conflict_findings)): + cap = CAPS["member_local_name_conflict"] + conflict_findings = conflict_findings[:cap] + findings.extend(conflict_findings) + + # compute score + score = 100 + for f in findings: + score -= f.deduction + if score < 0: + score = 0 + + return FileReport(path=str(path), score=score, findings=findings) + + +def render_text(reports: List[FileReport], min_score: Optional[int]) -> str: + """Render reports as plain text.""" + if not reports: + return "No files to analyze.\n" + + visible = reports if min_score is None else [r for r in reports if r.score <= min_score] + sorted_reports = sorted(visible, key=lambda r: r.score) + + out: List[str] = [] + width = 70 + out.append("=" * width) + out.append("Code Quality Score Report") + out.append("=" * width) + out.append("") + out.append(f"{'Score':>6} {'File'}") + out.append("-" * width) + for r in sorted_reports: + out.append(f"{r.score:>6} {r.path}") + out.append("") + + for r in sorted_reports: + if not r.findings: + continue + out.append("-" * width) + out.append(f"File: {r.path} (score: {r.score})") + out.append("-" * width) + for f in r.findings: + loc = f"line {f.line}" if f.line else "file" + out.append(f" [{f.rule}] {loc}: {f.reason} (-{f.deduction})") + out.append("") + + total = len(reports) + visible_n = len(visible) + avg = sum(r.score for r in reports) / total if total else 0.0 + passing = sum(1 for r in reports if r.score >= PASS_THRESHOLD) + out.append("=" * width) + out.append(f"Files scanned: {total}") + out.append(f"Files shown: {visible_n}") + out.append(f"Average score: {avg:.1f}") + out.append(f"Passing (>= {PASS_THRESHOLD}): {passing}/{total}") + out.append("=" * width) + return "\n".join(out) + "\n" + + +def render_json(reports: List[FileReport], min_score: Optional[int]) -> str: + visible = reports if min_score is None else [r for r in reports if r.score <= min_score] + return json.dumps({ + "summary": { + "total_scanned": len(reports), + "total_shown": len(visible), + "average_score": ( + sum(r.score for r in reports) / len(reports) if reports else 0.0 + ), + "passing": sum(1 for r in reports if r.score >= PASS_THRESHOLD), + "pass_threshold": PASS_THRESHOLD, + }, + "files": [r.to_dict() for r in sorted(visible, key=lambda r: r.score)], + }, indent=2) + + +def parse_args(argv: Optional[Sequence[str]] = None) -> argparse.Namespace: + parser = argparse.ArgumentParser( + description="ABACUS code quality scoring tool", + formatter_class=argparse.RawDescriptionHelpFormatter, + ) + parser.add_argument("paths", nargs="+", help="file or directory paths to scan") + parser.add_argument( + "--format", choices=["text", "json"], default="text", + help="output format (default: text)", + ) + parser.add_argument( + "--min-score", type=int, default=None, + help="only show files with score <= this value in output", + ) + parser.add_argument( + "--output", "-o", default=None, + help="write report to this file instead of stdout " + "(default: code_quality_score.txt when format is text and " + "no explicit output is given)", + ) + return parser.parse_args(argv) + + +def main(argv: Optional[Sequence[str]] = None) -> int: + args = parse_args(argv) + files = discover_files(args.paths) + if not files: + print(f"No source files found in: {args.paths}", file=sys.stderr) + return 1 + + reports = [analyze_file(f) for f in files] + + if args.format == "json": + rendered = render_json(reports, args.min_score) + else: + rendered = render_text(reports, args.min_score) + + out_path = args.output + if out_path is None and args.format == "text": + out_path = "code_quality_score.txt" + + if out_path: + Path(out_path).write_text(rendered, encoding="utf-8") + print( + f"Report written to {out_path} " + f"({len(reports)} files scanned, " + f"{sum(1 for r in reports if r.score >= PASS_THRESHOLD)} passing)", + file=sys.stderr, + ) + else: + print(rendered) + return 0 + + +if __name__ == "__main__": + sys.exit(main()) From c15fa10e9678f82357280dffb53852947c5d13e7 Mon Sep 17 00:00:00 2001 From: abacus_fixer Date: Thu, 20 Aug 2026 22:41:59 +0800 Subject: [PATCH 02/27] update --- tools/03_code_analysis/code_quality_score.py | 196 +++++++++++++++++++ 1 file changed, 196 insertions(+) diff --git a/tools/03_code_analysis/code_quality_score.py b/tools/03_code_analysis/code_quality_score.py index 69e71f71f7e..c0aa46a2a5d 100644 --- a/tools/03_code_analysis/code_quality_score.py +++ b/tools/03_code_analysis/code_quality_score.py @@ -24,6 +24,9 @@ - `friend` keyword exposing internals: -1 per occurrence (cap 5) - unpaired `new` without matching `delete`: -1 per occurrence (cap 5) - local variable shadowing a member variable: -1 per occurrence (cap 5) + - file longer than 500 lines: -1 per additional 50-line block + - each `new` keyword usage: -1 per occurrence (no cap) + - function with more than 7 parameters: -1 per extra param (cap 30 per file) Usage: python3 code_quality_score.py source/source_base @@ -51,6 +54,7 @@ ".git", "build", "__pycache__", "node_modules", ".cache", "third_party", "thirdparty", ".vscode", ".idea", ".trae-cn", "Dependencies", + "test", "tests", "test_parallel", "unit_test", "unittest", } CAPS = { @@ -84,10 +88,31 @@ "friend_keyword": 1, "unpaired_new_delete": 1, "member_local_name_conflict": 1, + "file_too_long": 1, + "raw_new_keyword": 1, + "too_many_parameters": 1, +} + +CAPS = { + "tab_indentation": 5, + "using_namespace_std": 5, + "line_too_long": 5, + "chinese_comment": 5, + "uppercase_constant": 5, + "default_parameter": 5, + "global_dependency": 10, + "hpp_include": 5, + "friend_keyword": 5, + "unpaired_new_delete": 5, + "member_local_name_conflict": 5, + "too_many_parameters": 30, } FUNCTION_LENGTH_THRESHOLD = 50 FUNCTION_LENGTH_STEP = 50 +FILE_LENGTH_THRESHOLD = 500 +FILE_LENGTH_STEP = 50 +FUNCTION_PARAM_THRESHOLD = 7 LINE_LENGTH_LIMIT = 120 FILENAME_LENGTH_LIMIT = 20 PASS_THRESHOLD = 60 @@ -125,6 +150,16 @@ "namespace", "enum", "union", ) +NON_FUNCTION_KEYWORDS = { + "if", "for", "while", "switch", "sizeof", "return", "throw", + "catch", "class", "struct", "namespace", "enum", "union", + "template", "static_assert", "typedef", "using", "new", + "delete", "operator", "do", "else", "goto", "continue", + "break", "try", +} +FUNC_NAME_RE = re.compile(r"\b([A-Za-z_]\w*)\s*\(") +QUALIFIER_RE = re.compile(r"\b(?:const|override|final|noexcept)\b") + @dataclass class Finding: @@ -366,6 +401,126 @@ def _match_var_decl(stripped_line: str) -> Optional[str]: return m.group(1) if m else None +def count_function_params(params_str: str) -> int: + """Count top-level parameters by counting commas at bracket depth 0. + + Tracks (), [] {} and <> as nesting (so commas inside std::map or + function-pointer params are not counted as param separators). + """ + s = params_str.strip() + if not s or s == "void": + return 0 + depth = 0 + count = 1 + for c in s: + if c in "([{<": + depth += 1 + elif c in ")]}>": + depth = max(0, depth - 1) + elif c == "," and depth == 0: + count += 1 + return count + + +def find_long_function_signatures( + content: str, threshold: int +) -> List[Tuple[int, str, int]]: + """Find function declarations/definitions whose parameter count exceeds threshold. + + Returns list of (line_no, function_name, param_count). Best-effort: + requires either a return-type prefix before the function name (for `;` + and `=` endings) or a `{` ending (for constructors/destructors which + have no return type). + """ + stripped = strip_comments(content) + n = len(stripped) + findings: List[Tuple[int, str, int]] = [] + + i = 0 + while i < n: + m = FUNC_NAME_RE.search(stripped, i) + if not m: + break + name = m.group(1) + if name in NON_FUNCTION_KEYWORDS: + i = m.end() + continue + + # inspect the prefix before `name(` to reject calls/lambdas/macros + line_start = stripped.rfind("\n", 0, m.start()) + 1 + prefix = stripped[line_start:m.start()] + prefix_stripped = prefix.rstrip() + prefix_lstripped = prefix.lstrip() + + # skip preprocessor lines + if prefix_lstripped.startswith("#"): + i = m.end() + continue + # skip lambdas: prefix ends with `]` + if prefix_stripped.endswith("]"): + i = m.end() + continue + # skip method calls: prefix ends with `.` or `->` + if prefix_stripped.endswith(".") or prefix_stripped.endswith("->"): + i = m.end() + continue + # skip assignment-result calls: prefix ends with `=` (but not `==`) + if prefix_stripped.endswith("=") and not prefix_stripped.endswith("=="): + i = m.end() + continue + # skip function-pointer typedefs + if "typedef" in prefix_stripped: + i = m.end() + continue + + # match parens to find params string + paren_open = m.end() - 1 + depth = 1 + j = paren_open + 1 + while j < n and depth > 0: + c = stripped[j] + if c == "(": + depth += 1 + elif c == ")": + depth -= 1 + if depth == 0: + break + j += 1 + if depth != 0: + i = m.end() + continue + params_str = stripped[paren_open + 1:j] + + # after `)`: optional qualifiers (const/override/final/noexcept), then ; { or = + after = stripped[j + 1:].lstrip() + k = 0 + while True: + mq = QUALIFIER_RE.match(after, k) + if not mq: + break + k = mq.end() + while k < len(after) and after[k] in " \t\n": + k += 1 + if k >= len(after) or after[k] not in ";{=": + i = j + 1 + continue + + # for `;` and `=`, require a return-type prefix (else it looks like a + # function call). For `{`, allow empty prefix (constructor/destructor). + if after[k] in ";=" and not prefix_stripped: + i = j + 1 + continue + + param_count = count_function_params(params_str) + if param_count > threshold: + line_no = stripped[:paren_open].count("\n") + 1 + findings.append((line_no, name, param_count)) + + i = j + 1 + + return findings + + def analyze_class_blocks(content: str) -> Tuple[List[Finding], List[Finding], List[Finding]]: """Analyze class/struct blocks for public member variables, long member functions, and member/local name conflicts. @@ -514,6 +669,21 @@ def analyze_file(path: Path) -> FileReport: lines = content.split("\n") + # file length rule (no cap: large files legitimately scale deduction) + total_lines = len(lines) + if total_lines > FILE_LENGTH_THRESHOLD: + excess = total_lines - FILE_LENGTH_THRESHOLD + blocks = (excess + FILE_LENGTH_STEP - 1) // FILE_LENGTH_STEP + findings.append(Finding( + rule="file_too_long", + line=None, + reason=( + f"file has {total_lines} lines " + f"(exceeds {FILE_LENGTH_THRESHOLD} by {excess})" + ), + deduction=blocks * WEIGHTS["file_too_long"], + )) + # line-based rules with caps tab_count = sum(1 for l in lines if "\t" in l) long_line_count = sum(1 for l in lines if len(l) > LINE_LENGTH_LIMIT) @@ -542,6 +712,9 @@ def analyze_file(path: Path) -> FileReport: delete_count = len(DELETE_EXPR_RE.findall(stripped_content)) unpaired_new = max(0, new_count - delete_count) + # raw `new` keyword usage: each occurrence costs 1 (no cap) + raw_new_count = new_count + def append_capped(rule: str, count: int) -> None: if count == 0: return @@ -565,6 +738,29 @@ def append_capped(rule: str, count: int) -> None: append_capped("hpp_include", hpp_include_count) append_capped("friend_keyword", friend_count) append_capped("unpaired_new_delete", unpaired_new) + append_capped("raw_new_keyword", raw_new_count) + + # too-many-parameters rule (per-function, capped across the file) + long_param_funcs = find_long_function_signatures(content, FUNCTION_PARAM_THRESHOLD) + cap_params = CAPS.get("too_many_parameters") + running_param_deduction = 0 + for line_no, fname, pcount in long_param_funcs: + excess = pcount - FUNCTION_PARAM_THRESHOLD + per_deduction = excess * WEIGHTS["too_many_parameters"] + if cap_params is not None and running_param_deduction + per_deduction > cap_params: + per_deduction = max(0, cap_params - running_param_deduction) + if per_deduction == 0: + break + running_param_deduction += per_deduction + findings.append(Finding( + rule="too_many_parameters", + line=line_no, + reason=( + f"function '{fname}' has {pcount} parameters " + f"(exceeds {FUNCTION_PARAM_THRESHOLD} by {excess})" + ), + deduction=per_deduction, + )) # class-based rules pub_findings, long_func_findings, conflict_findings = analyze_class_blocks(content) From c0b9ce74bb8b5f01c2e3c19d48abb68c76c172c1 Mon Sep 17 00:00:00 2001 From: abacus_fixer Date: Thu, 20 Aug 2026 22:51:41 +0800 Subject: [PATCH 03/27] Add cyclomatic complexity rule; raise file_too_long weight to 2 Extends tools/03_code_analysis/code_quality_score.py with two changes: - New `high_cyclomatic_complexity` rule: counts if/for/while/switch/case/ &&/|| per function body (McCabe complexity). Threshold 10, -1 per extra point, capped at 30 per file. Identifies functions that should be split. - `file_too_long` weight raised from -1 to -2 per 50-line block beyond 500 lines, reflecting the higher maintenance cost of very large files. Implementation: - `find_function_bodies()` locates function definitions with `{...}` bodies, reusing the prefix/reject logic from find_long_function_signatures so that function calls, lambdas, macros, and function-pointer typedefs are excluded. - `find_high_complexity_functions()` walks each body and counts control-flow keywords via CYCLO_KEYWORDS_RE. - Cyclomatic complexity follows McCabe: `else if` counts as two `if`, `switch` + each `case` count separately, `&&`/`||` each add 1. Scan results on source/ (1652 files, excluding test/ dirs): - Average score: 79.1 (was 82.1) - Passing rate (>=60): 1355/1652 = 82.1% - high_cyclomatic_complexity triggered: 594 functions - file_too_long triggered: 167 files Top offenders identified by the new rule: - source_hamilt/module_xc/xc_grad.cpp:28 `gradcorr` (complexity 145) - source_lcao/force_stress_lcao.cpp:69 `getForceStress` (103) - source_lcao/module_deepks/lcao_deepks_iface.cpp:63 `out_deepks_labels` (94) - source_io/module_ctrl/ctrl_scf_lcao.cpp:82 `ctrl_scf_lcao` (68) - source_estate/module_charge/charge.cpp:245 `atomic_rho` (60) --- tools/03_code_analysis/code_quality_score.py | 149 ++++++++++++++++++- 1 file changed, 147 insertions(+), 2 deletions(-) diff --git a/tools/03_code_analysis/code_quality_score.py b/tools/03_code_analysis/code_quality_score.py index c0aa46a2a5d..f88f8e96bf7 100644 --- a/tools/03_code_analysis/code_quality_score.py +++ b/tools/03_code_analysis/code_quality_score.py @@ -24,9 +24,11 @@ - `friend` keyword exposing internals: -1 per occurrence (cap 5) - unpaired `new` without matching `delete`: -1 per occurrence (cap 5) - local variable shadowing a member variable: -1 per occurrence (cap 5) - - file longer than 500 lines: -1 per additional 50-line block + - file longer than 500 lines: -2 per additional 50-line block - each `new` keyword usage: -1 per occurrence (no cap) - function with more than 7 parameters: -1 per extra param (cap 30 per file) + - function cyclomatic complexity > 10 (if/for/while/switch/case/&&/||): + -1 per extra point (cap 30 per file) Usage: python3 code_quality_score.py source/source_base @@ -88,9 +90,10 @@ "friend_keyword": 1, "unpaired_new_delete": 1, "member_local_name_conflict": 1, - "file_too_long": 1, + "file_too_long": 2, "raw_new_keyword": 1, "too_many_parameters": 1, + "high_cyclomatic_complexity": 1, } CAPS = { @@ -106,6 +109,7 @@ "unpaired_new_delete": 5, "member_local_name_conflict": 5, "too_many_parameters": 30, + "high_cyclomatic_complexity": 30, } FUNCTION_LENGTH_THRESHOLD = 50 @@ -113,6 +117,7 @@ FILE_LENGTH_THRESHOLD = 500 FILE_LENGTH_STEP = 50 FUNCTION_PARAM_THRESHOLD = 7 +CYCLO_THRESHOLD = 10 LINE_LENGTH_LIMIT = 120 FILENAME_LENGTH_LIMIT = 20 PASS_THRESHOLD = 60 @@ -159,6 +164,7 @@ } FUNC_NAME_RE = re.compile(r"\b([A-Za-z_]\w*)\s*\(") QUALIFIER_RE = re.compile(r"\b(?:const|override|final|noexcept)\b") +CYCLO_KEYWORDS_RE = re.compile(r"\b(?:if|for|while|switch|case)\b|&&|\|\|") @dataclass @@ -521,6 +527,123 @@ def find_long_function_signatures( return findings +def find_function_bodies(content: str) -> List[Tuple[int, str, int, int]]: + """Find function definitions (with body), not just declarations. + + Returns list of (signature_line_no, function_name, body_start_pos, + body_end_pos) where positions are absolute offsets in stripped content. + Reuses the prefix/reject logic from find_long_function_signatures. + """ + stripped = strip_comments(content) + n = len(stripped) + bodies: List[Tuple[int, str, int, int]] = [] + + i = 0 + while i < n: + m = FUNC_NAME_RE.search(stripped, i) + if not m: + break + name = m.group(1) + if name in NON_FUNCTION_KEYWORDS: + i = m.end() + continue + + line_start = stripped.rfind("\n", 0, m.start()) + 1 + prefix = stripped[line_start:m.start()] + prefix_stripped = prefix.rstrip() + prefix_lstripped = prefix.lstrip() + + if prefix_lstripped.startswith("#"): + i = m.end() + continue + if prefix_stripped.endswith("]"): + i = m.end() + continue + if prefix_stripped.endswith(".") or prefix_stripped.endswith("->"): + i = m.end() + continue + if prefix_stripped.endswith("=") and not prefix_stripped.endswith("=="): + i = m.end() + continue + if "typedef" in prefix_stripped: + i = m.end() + continue + + paren_open = m.end() - 1 + depth = 1 + j = paren_open + 1 + while j < n and depth > 0: + c = stripped[j] + if c == "(": + depth += 1 + elif c == ")": + depth -= 1 + if depth == 0: + break + j += 1 + if depth != 0: + i = m.end() + continue + + # find what comes after `)`: skip whitespace and qualifiers + pos = j + 1 + while pos < n and stripped[pos] in " \t\n": + pos += 1 + while True: + mq = QUALIFIER_RE.match(stripped, pos) + if not mq: + break + pos = mq.end() + while pos < n and stripped[pos] in " \t\n": + pos += 1 + + # we need a `{` body (not `;` declaration, not `= 0` pure virtual) + if pos >= n or stripped[pos] != "{": + i = j + 1 + continue + + # match braces to find body end + body_open = pos + depth = 1 + body_close = body_open + 1 + while body_close < n and depth > 0: + c = stripped[body_close] + if c == "{": + depth += 1 + elif c == "}": + depth -= 1 + if depth == 0: + break + body_close += 1 + if depth != 0: + i = j + 1 + continue + + sig_line_no = stripped[:paren_open].count("\n") + 1 + bodies.append((sig_line_no, name, body_open, body_close)) + i = body_close + 1 + + return bodies + + +def find_high_complexity_functions( + content: str, threshold: int +) -> List[Tuple[int, str, int]]: + """Find functions whose cyclomatic complexity exceeds threshold. + + Cyclomatic complexity counts: if, for, while, switch, case, &&, ||. + Returns list of (line_no, function_name, complexity). + """ + stripped = strip_comments(content) + findings: List[Tuple[int, str, int]] = [] + for sig_line, name, body_open, body_close in find_function_bodies(content): + body = stripped[body_open + 1:body_close] + complexity = len(CYCLO_KEYWORDS_RE.findall(body)) + if complexity > threshold: + findings.append((sig_line, name, complexity)) + return findings + + def analyze_class_blocks(content: str) -> Tuple[List[Finding], List[Finding], List[Finding]]: """Analyze class/struct blocks for public member variables, long member functions, and member/local name conflicts. @@ -762,6 +885,28 @@ def append_capped(rule: str, count: int) -> None: deduction=per_deduction, )) + # high cyclomatic complexity rule (per-function, capped across the file) + high_cyclo_funcs = find_high_complexity_functions(content, CYCLO_THRESHOLD) + cap_cyclo = CAPS.get("high_cyclomatic_complexity") + running_cyclo_deduction = 0 + for line_no, fname, cyclo in high_cyclo_funcs: + excess = cyclo - CYCLO_THRESHOLD + per_deduction = excess * WEIGHTS["high_cyclomatic_complexity"] + if cap_cyclo is not None and running_cyclo_deduction + per_deduction > cap_cyclo: + per_deduction = max(0, cap_cyclo - running_cyclo_deduction) + if per_deduction == 0: + break + running_cyclo_deduction += per_deduction + findings.append(Finding( + rule="high_cyclomatic_complexity", + line=line_no, + reason=( + f"function '{fname}' has cyclomatic complexity {cyclo} " + f"(exceeds {CYCLO_THRESHOLD} by {excess})" + ), + deduction=per_deduction, + )) + # class-based rules pub_findings, long_func_findings, conflict_findings = analyze_class_blocks(content) findings.extend(pub_findings) From e75318f45e9c74b42b1eebe728df50733470ef9f Mon Sep 17 00:00:00 2001 From: abacus_fixer Date: Fri, 21 Aug 2026 07:49:54 +0800 Subject: [PATCH 04/27] Add post-C++11 rule (-80); expand test dirs; fix string-literal false matches MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit This commit extends tools/03_code_analysis/code_quality_score.py with one new scoring rule, expands the test-file exclusion list, and fixes a critical class of false positives for keyword-based rules. 1. New rule: post_cpp11_feature (-80, one-shot per file) The ABACUS project keeps a C++11 baseline (see AGENTS.md § Required Baseline rule 7). Any newer syntax is a compilation risk on older compilers, so a one-shot -80 deduction is applied when any of the following high-confidence, low-false-positive patterns is seen: C++14 std::make_unique(...) digit separator in numeric literals (1'000'000) C++17 if constexpr (...) structured binding auto [a, b] = ...; fold expressions (args + ...), (... + args), etc. std::optional, std::variant, std::any [[nodiscard]], [[maybe_unused]] attributes C++20 concept / requires / consteval / constinit coroutine keywords: co_await, co_yield, co_return std::span, std::ranges::*, std::format(...) C++23 std::expected, std::print(...), std::println(...) Detection uses a list of (label, compiled_regex) pairs defined in POST_CPP11_PATTERNS. A single Finding is emitted per file listing all distinct features and their line numbers so the report is actionable. 2. Test directory exclusion: add "test_serial" to SKIP_DIRS The exclusion set previously contained {test, tests, test_parallel, unit_test, unittest} but missed test_serial/ under source_io and source_base; nine files leaked into score summaries. Now skipped. 3. False-positive fix: introduce strip_strings() helper strip_comments() erases comments but preserves string literals on purpose (brace-matching parsers later rely on the real quote boundaries). That meant keyword-based rules (e.g. the C++20 requires regex) matched ordinary words inside user-facing strings such as WARNING_QUIT("... eigensolver requires replicated ..."). The new strip_strings() function walks through content character by character, tracks "... " and '...' modes, and replaces every character inside quotes with a space (newlines are preserved so line numbers stay correct). find_post_cpp11_features() now runs on strip_strings(strip_comments(content)) — the double pass eliminates string-literal false matches while still catching real keywords. 4. Results on source/ (1643 files, excluding test dirs): - Avg score: 79.1 (previous scan w/ buggy version: 78.6) - Pass rate (>=60): 1348/1643 = 82.0% - post_cpp11_feature triggered on exactly 1 file after the fix: source/source_hsolver/diago_pexsi.cpp -> std::make_unique (C++14) The previous 16 files flagged as "requires (C++20)" were all string-literal false matches and are now correctly cleared. --- tools/03_code_analysis/code_quality_score.py | 216 ++++++++++++++++++- 1 file changed, 215 insertions(+), 1 deletion(-) diff --git a/tools/03_code_analysis/code_quality_score.py b/tools/03_code_analysis/code_quality_score.py index f88f8e96bf7..dfdc217aa66 100644 --- a/tools/03_code_analysis/code_quality_score.py +++ b/tools/03_code_analysis/code_quality_score.py @@ -29,6 +29,11 @@ - function with more than 7 parameters: -1 per extra param (cap 30 per file) - function cyclomatic complexity > 10 (if/for/while/switch/case/&&/||): -1 per extra point (cap 30 per file) + - post-C++11 feature usage: -80 per file (one-shot); detects high-confidence + C++14/17/20/23 tokens such as `std::make_unique`, `if constexpr`, + `[[nodiscard]]`, `auto [...]` structured bindings, `concept`, + `requires`, `consteval`, `co_await`, `std::optional`, `std::variant`, + `std::any`, `std::span`, `std::expected`, `std::format`, etc. Usage: python3 code_quality_score.py source/source_base @@ -56,7 +61,7 @@ ".git", "build", "__pycache__", "node_modules", ".cache", "third_party", "thirdparty", ".vscode", ".idea", ".trae-cn", "Dependencies", - "test", "tests", "test_parallel", "unit_test", "unittest", + "test", "tests", "test_serial", "test_parallel", "unit_test", "unittest", } CAPS = { @@ -94,6 +99,7 @@ "raw_new_keyword": 1, "too_many_parameters": 1, "high_cyclomatic_complexity": 1, + "post_cpp11_feature": 80, } CAPS = { @@ -166,6 +172,103 @@ QUALIFIER_RE = re.compile(r"\b(?:const|override|final|noexcept)\b") CYCLO_KEYWORDS_RE = re.compile(r"\b(?:if|for|while|switch|case)\b|&&|\|\|") +# Post-C++11 features with low false-positive rates. +# Each entry is (label, compiled_regex) — the label appears in the finding. +POST_CPP11_PATTERNS: List[Tuple[str, "re.Pattern[str]"]] = [ + # C++14 + ( + "std::make_unique", + re.compile(r"\bstd::make_unique\s*<"), + ), + ( + "digit-separator in numeric literal (C++14)", + re.compile(r"(?]=?|[.<>=])" + r"\s*\.\.\.\s*\)" + r"|\(\s*\.\.\.\s*(?:\+\+|\&\&|\|\||[+\-*/%^&|<>]=?|[.<>=])" + r"\s*[A-Za-z_]\w*\s*\)" + r"|\(\s*[A-Za-z_]\w*\s*(?:\+\+|\&\&|\|\||[+\-*/%^&|<>]=?|[.<>=])" + r"\s*\.\.\.\s*(?:\+\+|\&\&|\|\||[+\-*/%^&|<>]=?|[.<>=])" + r"\s*[^,)]+\s*\)" + ), + ), + ( + "std::optional (C++17)", + re.compile(r"\bstd::optional\b"), + ), + ( + "std::variant (C++17)", + re.compile(r"\bstd::variant\b"), + ), + ( + "std::any (C++17)", + re.compile(r"\bstd::any\b"), + ), + ( + "[[nodiscard]] (C++17)", + re.compile(r"\[\[nodiscard\b"), + ), + ( + "[[maybe_unused]] (C++17)", + re.compile(r"\[\[maybe_unused\b"), + ), + # C++20 + ( + "concept (C++20)", + re.compile(r"\bconcept\b"), + ), + ( + "requires (C++20)", + re.compile(r"\brequires\b"), + ), + ( + "consteval (C++20)", + re.compile(r"\bconsteval\b"), + ), + ( + "constinit (C++20)", + re.compile(r"\bconstinit\b"), + ), + ( + "coroutine co_await / co_yield / co_return (C++20)", + re.compile(r"\bco_(?:await|yield|return)\b"), + ), + ( + "std::span (C++20)", + re.compile(r"\bstd::span\b"), + ), + ( + "std::ranges (C++20)", + re.compile(r"\bstd::ranges::"), + ), + ( + "std::format (C++20)", + re.compile(r"\bstd::format\b"), + ), + # C++23 + ( + "std::expected (C++23)", + re.compile(r"\bstd::expected\b"), + ), + ( + "std::print / std::println (C++23)", + re.compile(r"\bstd::print(?:ln)?\s*\("), + ), +] + @dataclass class Finding: @@ -285,6 +388,77 @@ def strip_comments(content: str) -> str: return "".join(out) +def strip_strings(content: str) -> str: + """Return content with string and character literals erased to spaces, + preserving line numbers. + + The result still has the same number of characters and lines, but no + letter/word survives inside "..." or '...'. This prevents false matches + on keywords that happen to appear inside string literals. + """ + out = [] + i = 0 + n = len(content) + in_string = False + in_char = False + while i < n: + c = content[i] + if in_string: + if c == "\\" and i + 1 < n: + # keep the escape sequence length but blank it out + out.append(" ") + if content[i + 1] == "\n": + out.append("\n") + else: + out.append(" ") + i += 2 + continue + if c == '"': + in_string = False + out.append('"') # keep the boundary marker (safest for line numbers) + i += 1 + continue + if c == "\n": + out.append("\n") + else: + out.append(" ") + i += 1 + continue + if in_char: + if c == "\\" and i + 1 < n: + out.append(" ") + if content[i + 1] == "\n": + out.append("\n") + else: + out.append(" ") + i += 2 + continue + if c == "'": + in_char = False + out.append("'") + i += 1 + continue + if c == "\n": + out.append("\n") + else: + out.append(" ") + i += 1 + continue + if c == '"': + in_string = True + out.append('"') + i += 1 + continue + if c == "'": + in_char = True + out.append("'") + i += 1 + continue + out.append(c) + i += 1 + return "".join(out) + + def find_class_blocks(code: str) -> List[Tuple[int, int, str, str]]: """Find top-level class/struct blocks. Returns list of (start_line_1indexed, end_line_1indexed, kind, name). @@ -644,6 +818,30 @@ def find_high_complexity_functions( return findings +def find_post_cpp11_features( + content: str, +) -> List[Tuple[int, str]]: + """Find the first occurrence of each post-C++11 feature. + + Uses the patterns in POST_CPP11_PATTERNS against content with both + comments AND string literals blanked out. String blanking prevents + false matches on keywords embedded in user-facing messages (e.g. + `"X requires Y"` in a WARNING_QUIT call). + + Returns a list of (line_no, feature_label) — one entry per distinct + detected feature so the finding message is informative (the deduction + is one-shot -80 per file regardless of how many features hit). + """ + stripped = strip_strings(strip_comments(content)) + hits: List[Tuple[int, str]] = [] + for label, regex in POST_CPP11_PATTERNS: + m = regex.search(stripped) + if m: + line_no = stripped[:m.start()].count("\n") + 1 + hits.append((line_no, label)) + return hits + + def analyze_class_blocks(content: str) -> Tuple[List[Finding], List[Finding], List[Finding]]: """Analyze class/struct blocks for public member variables, long member functions, and member/local name conflicts. @@ -907,6 +1105,22 @@ def append_capped(rule: str, count: int) -> None: deduction=per_deduction, )) + # post-C++11 feature rule: one-shot -80, lists all distinct features + post_cpp11_hits = find_post_cpp11_features(content) + if post_cpp11_hits: + feature_list = ", ".join( + f"'{label}' (line {ln})" for ln, label in post_cpp11_hits + ) + findings.append(Finding( + rule="post_cpp11_feature", + line=post_cpp11_hits[0][0], + reason=( + f"uses post-C++11 feature(s): {feature_list} " + f"(repo baseline is C++11)" + ), + deduction=WEIGHTS["post_cpp11_feature"], + )) + # class-based rules pub_findings, long_func_findings, conflict_findings = analyze_class_blocks(content) findings.extend(pub_findings) From c961e6903694a6a12b601c05aadb5ffe7ddccf00 Mon Sep 17 00:00:00 2001 From: abacus_fixer Date: Fri, 21 Aug 2026 07:51:45 +0800 Subject: [PATCH 05/27] use code quality tool to fix issues in wavefunc_in_pw files --- source/source_lcao/wavefunc_in_pw.cpp | 744 +++++++++++++------------- source/source_lcao/wavefunc_in_pw.h | 38 +- 2 files changed, 398 insertions(+), 384 deletions(-) diff --git a/source/source_lcao/wavefunc_in_pw.cpp b/source/source_lcao/wavefunc_in_pw.cpp index 1ff08b2e5e7..47a0005c385 100644 --- a/source/source_lcao/wavefunc_in_pw.cpp +++ b/source/source_lcao/wavefunc_in_pw.cpp @@ -1,4 +1,5 @@ #include // Peize Lin fix bug about strcmp 2016-08-02 +#include #include "wavefunc_in_pw.h" #include "source_io/module_parameter/parameter.h" #include "source_base/math_integral.h" @@ -7,175 +8,174 @@ #include "source_base/math_ylmreal.h" void Wavefunc_in_pw::make_table_q( - const UnitCell &ucell, - std::vector &fn, - ModuleBase::realArray &table_local) + const UnitCell &ucell, + std::vector &fn, + ModuleBase::realArray &table_local) { - ModuleBase::TITLE("Wavefunc_in_pw","make_table_q"); - - if( fn.size() != static_cast(ucell.ntype) ) - { - ModuleBase::WARNING_QUIT("Wavefunc_in_pw::make_table_q","maybe NUMERICAL_ORBITAL is not read in, please check."); - } - - for(int it=0; it> word; - if (std::strcmp(word , "END") == 0) // Peize Lin fix bug about strcmp 2016-08-02 - { - break; - } - } - - ModuleBase::CHECK_NAME(in, "Mesh"); - in >> meshr; - int meshr_read = meshr; - if(meshr%2==0) - { - ++meshr; - } - GlobalV::ofs_running << " meshr=" << meshr; - - ModuleBase::CHECK_NAME(in, "dr"); - in >> dr; - GlobalV::ofs_running << " dr=" << dr; - - double* radial = new double[meshr]; - double *psi = new double[meshr]; - double* psir = new double[meshr]; - double* rab = new double[meshr]; - - ModuleBase::GlobalFunc::ZEROS(radial, meshr); - ModuleBase::GlobalFunc::ZEROS(psi, meshr); - ModuleBase::GlobalFunc::ZEROS(psir, meshr); - ModuleBase::GlobalFunc::ZEROS(rab, meshr); - for(int ir=0; ir> name1 >> name2 >> name3; - assert( name1 == "Type" ); - in >> tmp_it >> tmp_l >> tmp_n; - if( L == tmp_l && N == tmp_n ) - { - // meshr_read is different from meshr if meshr is even number. - for(int ir=0; ir> psi[ir]; - //psi[ir] = 1.0; //hahaha - psir[ir] = psi[ir] * radial[ir]; - } - find = true; - } - else - { - double no_use = 0.0; - for(int ir=0; ir> no_use; - } - } - } - double* table = new double[PARAM.globalv.nqx]; - Wavefunc_in_pw::integral(ucell,meshr, psir, radial, rab, L, table); - for(int iq=0; iq(ucell.ntype) ) + { + ModuleBase::WARNING_QUIT( + "Wavefunc_in_pw::make_table_q", + "maybe NUMERICAL_ORBITAL is not read in, please check." + ); + } + + for(int it=0; it> word; + if (std::strcmp(word , "END") == 0) // Peize Lin fix bug about strcmp 2016-08-02 + { + break; + } + } + + ModuleBase::CHECK_NAME(in, "Mesh"); + in >> meshr; + int meshr_read = meshr; + if(meshr%2==0) + { + ++meshr; + } + GlobalV::ofs_running << " meshr=" << meshr; + + ModuleBase::CHECK_NAME(in, "dr"); + in >> dr; + GlobalV::ofs_running << " dr=" << dr; + + std::vector radial(meshr); + std::vector psi(meshr); + std::vector psir(meshr); + std::vector rab(meshr); + + ModuleBase::GlobalFunc::ZEROS(radial.data(), meshr); + ModuleBase::GlobalFunc::ZEROS(psi.data(), meshr); + ModuleBase::GlobalFunc::ZEROS(psir.data(), meshr); + ModuleBase::GlobalFunc::ZEROS(rab.data(), meshr); + for(int ir=0; ir> name1 >> name2 >> name3; + assert( name1 == "Type" ); + in >> tmp_it >> tmp_l >> tmp_n; + if( L == tmp_l && N == tmp_n ) + { + // meshr_read is different from meshr if meshr is even number. + for(int ir=0; ir> psi[ir]; + //psi[ir] = 1.0; //hahaha + psir[ir] = psi[ir] * radial[ir]; + } + find = true; + } + else + { + double no_use = 0.0; + for(int ir=0; ir> no_use; + } + } + } + std::vector table(PARAM.globalv.nqx); + Wavefunc_in_pw::integral( + ucell, meshr, psir.data(), radial.data(), rab.data(), L, table.data()); + for (int iq = 0; iq < PARAM.globalv.nqx; ++iq) + { + //double energy_q = pow(iq * PARAM.globalv.dq,2); + table_local(it, ic, iq) = table[iq];//* Wavefunc_in_pw::smearing(energy_q,150,0.666666); + } + ++ic; + }// N + }// L + }// T + + + if(GlobalV::MY_RANK==0) + { + for(int it=0; it inner_part(meshr); + for (int ir = 0; ir < meshr; ++ir) + { + inner_part[ir] = psir[ir] * psir[ir]; + } + + double unit = 0.0; + ModuleBase::Integral::Simpson_Integral(meshr, inner_part.data(), rab, unit); + ModuleBase::GlobalFunc::OUT(GlobalV::ofs_running, "normalize unit", unit); + + std::vector aux(meshr); + std::vector vchi(meshr); + for (int iq = 0; iq < PARAM.globalv.nqx; ++iq) + { + const double q = PARAM.globalv.dq * iq; + ModuleBase::Sphbes::Spherical_Bessel(meshr, r, q, l, aux.data()); + for (int ir = 0; ir < meshr; ++ir) + { + vchi[ir] = psir[ir] * aux[ir] * r[ir]; + } + + double vqint = 0.0; + ModuleBase::Integral::Simpson_Integral(meshr, vchi.data(), rab, vqint); + + table[iq] = vqint * pref; + } + return; } void Wavefunc_in_pw::produce_local_basis_in_pw(const UnitCell& ucell, - const int& ik, + const int& ik, const ModulePW::PW_Basis_K* wfc_basis, const Structure_Factor& sf, ModuleBase::ComplexMatrix& psi, const ModuleBase::realArray& table_local) { - ModuleBase::TITLE("Wavefunc_in_pw","produce_local_basis_in_pw"); - assert(ik>=0); - const int npw = wfc_basis->npwk[ik]; - const int total_lm = ( ucell.lmax + 1) * ( ucell.lmax + 1); - ModuleBase::matrix ylm(total_lm, npw); - std::complex *aux = new std::complex[npw]; - double *chiaux = nullptr; - - ModuleBase::Vector3 *gk = new ModuleBase::Vector3[npw]; - for(int ig=0;iggetgpluskcar(ik, ig); - } - - ModuleBase::YlmReal::Ylm_Real(total_lm, npw, gk, ylm); - - //int index = 0; - double *flq = new double[npw]; - int iwall=0; - for (int it = 0;it < ucell.ntype;it++) - { - for (int ia = 0;ia < ucell.atoms[it].na;ia++) - { + ModuleBase::TITLE("Wavefunc_in_pw","produce_local_basis_in_pw"); + assert(ik>=0); + const int npw = wfc_basis->npwk[ik]; + const int total_lm = ( ucell.lmax + 1) * ( ucell.lmax + 1); + ModuleBase::matrix ylm(total_lm, npw); + std::vector> aux(npw); + std::vector chiaux; + bool chiaux_init = false; + + std::vector> gk(npw); + for (int ig = 0; ig < npw; ++ig) + { + gk[ig] = wfc_basis->getgpluskcar(ik, ig); + } + + ModuleBase::YlmReal::Ylm_Real(total_lm, npw, gk.data(), ylm); + + //int index = 0; + std::vector flq(npw); + int iwall=0; + for (int it = 0;it < ucell.ntype;it++) + { + for (int ia = 0;ia < ucell.atoms[it].na;ia++) + { std::complex* sk = sf.get_sk(ik, it, ia, wfc_basis); int ic = 0; for(int L = 0; L < ucell.atoms[it].nwl+1; L++) - { - std::complex lphase = pow(ModuleBase::NEG_IMAG_UNIT, L); //mohan 2010-04-19 - for(int N=0; N < ucell.atoms[it].l_nchi[L]; N++) - { -// GlobalV::ofs_running << " it=" << it << " ia=" << ia << " L=" << L << " N=" << N << std::endl; - - for(int ig=0; ig lphase = pow(ModuleBase::NEG_IMAG_UNIT, L); //mohan 2010-04-19 + for(int N=0; N < ucell.atoms[it].l_nchi[L]; N++) + { +// GlobalV::ofs_running << " it=" << it << " ia=" << ia << " L=" << L << " N=" << N << std::endl; + + for(int ig=0; ignpwk_max) = lphase * sk[ig] * ylm(lm, ig) * flq[ig]; } iwall += 2; } - }//if - else - {//atomic_wfc_so_mag - double alpha = 0.0, gamma = 0.0; - std::complex fup,fdown; - //int nc; - //This routine creates two functions only in the case j=l+1/2 or exit in the other case - if(fabs(j-L+0.5)<1e-4) { continue; + }//if + else + {//atomic_wfc_so_mag + double alpha = 0.0, gamma = 0.0; + std::complex fup,fdown; + //int nc; + // This routine creates two functions only + // in the case j=l+1/2 or exit otherwise + if(fabs(j-L+0.5)<1e-4) { continue; } - delete[] chiaux; - chiaux = new double [npw]; - //Find the functions j= l- 1/2 - if(L==0) { - for(int ig=0;ig ucell.natomwfc) { @@ -375,92 +385,96 @@ void Wavefunc_in_pw::produce_local_basis_in_pw(const UnitCell& ucell, aux[ig] = sk[ig] * ylm(lm,ig) * chiaux[ig]; } //rotate wfc as needed - //first rotation with angle alpha around (OX) - for(int ig = 0;ignpwk_max) = (cos(0.5 * gamma) - ModuleBase::IMAG_UNIT * sin(0.5 * gamma)) * fdown; // second rotation with angle gamma around(OZ) fup = cos(0.5 * (alpha + ModuleBase::PI)) * aux[ig]; fdown = ModuleBase::IMAG_UNIT * sin(0.5 * (alpha + ModuleBase::PI))*aux[ig]; - psi(iwall+2*L+1,ig) = (cos(0.5*gamma) + ModuleBase::IMAG_UNIT*sin(0.5*gamma))*fup; + psi(iwall + 2 * L + 1, ig) = + (cos(0.5 * gamma) + ModuleBase::IMAG_UNIT * sin(0.5 * gamma)) + * fup; psi(iwall + 2 * L + 1, ig + wfc_basis->npwk_max) = (cos(0.5 * gamma) - ModuleBase::IMAG_UNIT * sin(0.5 * gamma)) * fdown; } iwall++; } - iwall += 2*L +1; - } // end else INPUT.starting_spin_angle || !PARAM.globalv.domag - } // end if ucell.atoms[it].has_so - else - {//atomic_wfc_nc - double alpha = 0.0, gamman = 0.0; - std::complex fup = 0.0, fdown = 0.0; - alpha = ucell.atoms[it].angle1[ia]; - gamman = -ucell.atoms[it].angle2[ia] + 0.5*ModuleBase::PI; - for(int m = 0;m<2*L+1;m++) - { - const int lm = L*L +m; - if (iwall + 2 * L + 1 > ucell.natomwfc) - { - ModuleBase::WARNING_QUIT("this->wf.atomic_wfc()", "error: too many wfcs"); - } + iwall += 2*L +1; + } // end else INPUT.starting_spin_angle || !PARAM.globalv.domag + } // end if ucell.atoms[it].has_so + else + {//atomic_wfc_nc + double alpha = 0.0, gamman = 0.0; + std::complex fup = 0.0, fdown = 0.0; + alpha = ucell.atoms[it].angle1[ia]; + gamman = -ucell.atoms[it].angle2[ia] + 0.5*ModuleBase::PI; + for(int m = 0;m<2*L+1;m++) + { + const int lm = L*L +m; + if (iwall + 2 * L + 1 > ucell.natomwfc) + { + ModuleBase::WARNING_QUIT("this->wf.atomic_wfc()", "error: too many wfcs"); + } for (int ig = 0; ig < npw; ig++) { aux[ig] = sk[ig] * ylm(lm,ig) * flq[ig]; } //rotate function - //first, rotation with angle alpha around(OX) - for(int ig = 0;ignpwk_max) = (cos(0.5 * gamman) - ModuleBase::IMAG_UNIT * sin(0.5 * gamman)) * fdown; // second rotation with angle gamma around(OZ) fup = cos(0.5 * (alpha + ModuleBase::PI)) * aux[ig]; fdown = ModuleBase::IMAG_UNIT * sin(0.5 * (alpha + ModuleBase::PI)) * aux[ig]; - psi(iwall+2*L+1,ig) = (cos(0.5*gamman) + ModuleBase::IMAG_UNIT*sin(0.5*gamman))*fup; + psi(iwall + 2 * L + 1, ig) = + (cos(0.5 * gamman) + ModuleBase::IMAG_UNIT * sin(0.5 * gamman)) + * fup; psi(iwall + 2 * L + 1, ig + wfc_basis->npwk_max) = (cos(0.5 * gamman) - ModuleBase::IMAG_UNIT * sin(0.5 * gamman)) * fdown; } // end ig iwall++; } // end m - iwall += 2*L+1; - } // end else ucell.atoms[it].has_so - } // end for is_N + iwall += 2*L+1; + } // end else ucell.atoms[it].has_so + } // end for is_N } // end if PARAM.inp.noncolin - else - {//LSDA and nomagnet case - for(int m=0; m<2*L+1; m++) - { - const int lm = L*L+m; - for(int ig=0; ig &orbital_files, - ModuleBase::realArray &table_local); + void make_table_q( + const UnitCell &ucell, + std::vector &orbital_files, + ModuleBase::realArray &table_local); - void integral( - const UnitCell& ucell, - const int meshr, // number of mesh points - const double *psir, - const double *r, - const double *rab, - const int &l, - double* table); - - //mohan add 2010-04-20 - double smearing( - const double &energy_x, - const double &ecut, - const double &beta); + void integral( + const UnitCell& ucell, + const int meshr, // number of mesh points + const double *psir, + const double *r, + const double *rab, + const int &l, + double* table); + + //mohan add 2010-04-20 + double smearing( + const double &energy_x, + const double &ecut, + const double &beta); void produce_local_basis_in_pw(const UnitCell& ucell, - const int& ik, + const int& ik, const ModulePW::PW_Basis_K* wfc_basis, const Structure_Factor& sf, ModuleBase::ComplexMatrix& psi, From c657f474f28dde8ee2171b9f925301d2a6231eae Mon Sep 17 00:00:00 2001 From: abacus_fixer Date: Sun, 23 Aug 2026 21:24:27 +0800 Subject: [PATCH 06/27] update code_quality_score --- tools/03_code_analysis/code_quality_score.py | 80 ++++++++++++++------ 1 file changed, 55 insertions(+), 25 deletions(-) diff --git a/tools/03_code_analysis/code_quality_score.py b/tools/03_code_analysis/code_quality_score.py index dfdc217aa66..347abbd5862 100644 --- a/tools/03_code_analysis/code_quality_score.py +++ b/tools/03_code_analysis/code_quality_score.py @@ -4,36 +4,66 @@ Scans source files/directories and assigns each file a quality score starting from 100, deducting points for each rule violation found. -Rules (per-file score starts at 100): - Core rules: - - filename stem longer than 20 chars: -1 - - filename contains uppercase letters: -1 - - filename extension is .hpp: -50 +General semantics: + - Score is clamped to a minimum of 0 (a file cannot go negative even + when post-C++11 + .hpp alone would force it below 0). + - All caps listed below are per-file limits on the cumulative + deduction for that rule within a single file. + - Files under any of these directories are skipped entirely: test/, + tests/, test_serial/, test_parallel/, unit_test/, unittest/. + - Pass threshold: score >= 60. Output is sorted by score ascending + (worst files first) and written to ./code_quality_score.txt by + default when format is text and no -o is given. + +Rules (per-file score starts at 100), grouped by concern and ordered +by per-rule severity within each group: + + 1. Architecture & compliance (AGENTS.md red lines): + - post-C++11 feature usage: -80 per file (one-shot). High one-shot + weight because it violates the repo-wide C++11 baseline + contract (AGENTS.md §7). Detects high-confidence C++14/17/20/23 + tokens such as `std::make_unique`, `if constexpr`, + `[[nodiscard]]`, `auto [...]` structured bindings, `concept`, + `requires`, `consteval`, `co_await`, `std::optional`, + `std::variant`, `std::any`, `std::span`, `std::expected`, + `std::format`, etc. + - filename extension is .hpp: -50 (AGENTS.md §4) + - GlobalV::/GlobalC::/PARAM.* cross-layer dependency: -3 per + occurrence (cap 10) (AGENTS.md §1) + - function declaration with default parameter: -2 per occurrence + (cap 5) (AGENTS.md §5) + - #include of .hpp implementation header: -2 per occurrence + (cap 5) (AGENTS.md §3, §4) - each public member variable in a class/struct: -1 - - member function longer than 50 lines: -1 per additional 50-line block - Zero-cost rules (no C++ parsing needed): + - `friend` keyword exposing internals: -1 per occurrence (cap 5) + + 2. Size, complexity & memory (implementation-level maintainability): + - function with more than 7 parameters: -1 per extra param + (cap 30 per file) + - function cyclomatic complexity > 10 (if/for/while/switch/case/ + &&/||): -1 per extra point (cap 30 per file) + - file longer than 500 lines: -2 per additional 50-line block + (counts all physical lines including blanks and comments; no cap) + - member function longer than 50 lines: -1 per additional 50-line + block (counts physical lines after comments are blanked, blanks + preserved) + - each `new` keyword usage: -1 per occurrence (no cap) + - unpaired `new` without matching `delete`: -1 per occurrence + (cap 5). NOTE: stacks with the `new` rule above, so an unpaired + `new` costs -2 total (-1 from `new` + -1 from unpaired). + - local variable shadowing a member variable: -1 per occurrence + (cap 5) + + 3. Naming & formatting (lightweight surface rules, regex-based): + - filename stem longer than 20 chars: -1 (stem = filename without + extension, e.g. `matrix_orbs11.cpp` -> stem `matrix_orbs11`) + - filename contains uppercase letters: -1 + - UPPERCASE constant naming (>3 chars all caps): -1 per occurrence + (cap 5) - tab indentation: -1 per line (cap 5) - `using namespace std;`: -1 per occurrence (cap 5) - line longer than 120 chars: -1 per line (cap 5) - Chinese characters in comments/code: -1 per line (cap 5) - - UPPERCASE constant naming (>3 chars all caps): -1 per occurrence (cap 5) - Interface & dependency rules: - - function declaration with default parameter: -2 per occurrence (cap 5) - - GlobalV::/GlobalC::/PARAM.* cross-layer dependency: -3 per occurrence (cap 10) - - #include of .hpp implementation header: -2 per occurrence (cap 5) - - `friend` keyword exposing internals: -1 per occurrence (cap 5) - - unpaired `new` without matching `delete`: -1 per occurrence (cap 5) - - local variable shadowing a member variable: -1 per occurrence (cap 5) - - file longer than 500 lines: -2 per additional 50-line block - - each `new` keyword usage: -1 per occurrence (no cap) - - function with more than 7 parameters: -1 per extra param (cap 30 per file) - - function cyclomatic complexity > 10 (if/for/while/switch/case/&&/||): - -1 per extra point (cap 30 per file) - - post-C++11 feature usage: -80 per file (one-shot); detects high-confidence - C++14/17/20/23 tokens such as `std::make_unique`, `if constexpr`, - `[[nodiscard]]`, `auto [...]` structured bindings, `concept`, - `requires`, `consteval`, `co_await`, `std::optional`, `std::variant`, - `std::any`, `std::span`, `std::expected`, `std::format`, etc. Usage: python3 code_quality_score.py source/source_base From b5455f737187aceca2bf03cb323b46be87a12323 Mon Sep 17 00:00:00 2001 From: abacus_fixer Date: Sun, 23 Aug 2026 21:53:53 +0800 Subject: [PATCH 07/27] update code_quality_score --- tools/03_code_analysis/code_quality_score.py | 148 ++++++++++++++++--- 1 file changed, 125 insertions(+), 23 deletions(-) diff --git a/tools/03_code_analysis/code_quality_score.py b/tools/03_code_analysis/code_quality_score.py index 347abbd5862..b609474c362 100644 --- a/tools/03_code_analysis/code_quality_score.py +++ b/tools/03_code_analysis/code_quality_score.py @@ -6,27 +6,35 @@ General semantics: - Score is clamped to a minimum of 0 (a file cannot go negative even - when post-C++11 + .hpp alone would force it below 0). + when post-C++11 + .hpp alone would force it below 0). The + unclamped value is preserved as `real_score`: shown in the text + report as `(real_score=N)` next to clamped-0 files, included in + JSON output, and used to break ties among clamped-0 files. - All caps listed below are per-file limits on the cumulative deduction for that rule within a single file. - Files under any of these directories are skipped entirely: test/, tests/, test_serial/, test_parallel/, unit_test/, unittest/. - Pass threshold: score >= 60. Output is sorted by score ascending - (worst files first) and written to ./code_quality_score.txt by - default when format is text and no -o is given. + (worst files first); ties are broken by `real_score` ascending + (more negative = more total deduction = ranked first). Text and + JSON output also include a per-module rollup grouped by the + `source/source_*` prefix (worst module first). Written to + ./code_quality_score.txt by default when format is text and no -o + is given. Rules (per-file score starts at 100), grouped by concern and ordered by per-rule severity within each group: 1. Architecture & compliance (AGENTS.md red lines): - - post-C++11 feature usage: -80 per file (one-shot). High one-shot - weight because it violates the repo-wide C++11 baseline - contract (AGENTS.md §7). Detects high-confidence C++14/17/20/23 - tokens such as `std::make_unique`, `if constexpr`, - `[[nodiscard]]`, `auto [...]` structured bindings, `concept`, - `requires`, `consteval`, `co_await`, `std::optional`, - `std::variant`, `std::any`, `std::span`, `std::expected`, - `std::format`, etc. + - post-C++11 feature usage: -40 base + -8 per distinct feature + (cap 5). Total max -80, matching the previous one-shot weight, + but a single misuse no longer swamps the whole file. High weight + because it violates the repo-wide C++11 baseline contract + (AGENTS.md §7). Detects high-confidence C++14/17/20/23 tokens + such as `std::make_unique`, `if constexpr`, `[[nodiscard]]`, + `auto [...]` structured bindings, `concept`, `requires`, + `consteval`, `co_await`, `std::optional`, `std::variant`, + `std::any`, `std::span`, `std::expected`, `std::format`, etc. - filename extension is .hpp: -50 (AGENTS.md §4) - GlobalV::/GlobalC::/PARAM.* cross-layer dependency: -3 per occurrence (cap 10) (AGENTS.md §1) @@ -129,7 +137,8 @@ "raw_new_keyword": 1, "too_many_parameters": 1, "high_cyclomatic_complexity": 1, - "post_cpp11_feature": 80, + "post_cpp11_feature": 40, + "post_cpp11_per_feature": 8, } CAPS = { @@ -146,6 +155,7 @@ "member_local_name_conflict": 5, "too_many_parameters": 30, "high_cyclomatic_complexity": 30, + "post_cpp11_per_feature": 5, } FUNCTION_LENGTH_THRESHOLD = 50 @@ -313,11 +323,13 @@ class FileReport: path: str score: int findings: List[Finding] = field(default_factory=list) + real_score: int = 100 def to_dict(self) -> dict: return { "path": self.path, "score": self.score, + "real_score": self.real_score, "findings": [ { "rule": f.rule, @@ -1135,7 +1147,9 @@ def append_capped(rule: str, count: int) -> None: deduction=per_deduction, )) - # post-C++11 feature rule: one-shot -80, lists all distinct features + # post-C++11 feature rule: base deduction for any usage + per-feature + # incremental deduction (capped). Total cap matches the previous + # one-shot -80, but a single misuse no longer swamps the whole file. post_cpp11_hits = find_post_cpp11_features(content) if post_cpp11_hits: feature_list = ", ".join( @@ -1150,6 +1164,22 @@ def append_capped(rule: str, count: int) -> None: ), deduction=WEIGHTS["post_cpp11_feature"], )) + num_features = len(post_cpp11_hits) + cap_features = CAPS.get("post_cpp11_per_feature", num_features) + capped = min(num_features, cap_features) + if capped > 0: + cap_text = ( + f" (capped at {cap_features})" if num_features > cap_features else "" + ) + findings.append(Finding( + rule="post_cpp11_per_feature", + line=post_cpp11_hits[0][0], + reason=( + f"{num_features} distinct post-C++11 feature(s) detected" + f"{cap_text}" + ), + deduction=capped * WEIGHTS["post_cpp11_per_feature"], + )) # class-based rules pub_findings, long_func_findings, conflict_findings = analyze_class_blocks(content) @@ -1161,14 +1191,59 @@ def append_capped(rule: str, count: int) -> None: conflict_findings = conflict_findings[:cap] findings.extend(conflict_findings) - # compute score - score = 100 + # compute score: real_score is the unclamped value (may be negative); + # score is clamped to a minimum of 0 for display. + real_score = 100 for f in findings: - score -= f.deduction - if score < 0: - score = 0 + real_score -= f.deduction + score = max(0, real_score) + + return FileReport( + path=str(path), + score=score, + findings=findings, + real_score=real_score, + ) + - return FileReport(path=str(path), score=score, findings=findings) +def get_module(path: str) -> str: + """Group a file path into its module for rollup purposes. + + Returns the `source/source_*` prefix when present (e.g. + `source/source_lcao`); otherwise falls back to the file's parent + directory. Backslashes are normalised to forward slashes. + """ + parts = path.replace("\\", "/").split("/") + for i, p in enumerate(parts): + if ( + p == "source" + and i + 1 < len(parts) + and parts[i + 1].startswith("source_") + ): + return f"source/{parts[i + 1]}" + return "/".join(parts[:-1]) if len(parts) > 1 else path + + +def compute_module_rollup( + reports: List[FileReport], +) -> List[Tuple[str, int, float, int]]: + """Group reports by module and return rows sorted by avg score ascending. + + Each row is (module, file_count, average_score, passing_count). + Worst module (lowest average) appears first. + """ + groups: dict = {} + for r in reports: + m = get_module(r.path) + groups.setdefault(m, []).append(r) + rows: List[Tuple[str, int, float, int]] = [] + for module, rs in groups.items(): + n = len(rs) + avg = sum(r.score for r in rs) / n if n else 0.0 + passing = sum(1 for r in rs if r.score >= PASS_THRESHOLD) + rows.append((module, n, avg, passing)) + rows.sort(key=lambda x: x[2]) + return rows def render_text(reports: List[FileReport], min_score: Optional[int]) -> str: @@ -1177,18 +1252,35 @@ def render_text(reports: List[FileReport], min_score: Optional[int]) -> str: return "No files to analyze.\n" visible = reports if min_score is None else [r for r in reports if r.score <= min_score] - sorted_reports = sorted(visible, key=lambda r: r.score) + sorted_reports = sorted(visible, key=lambda r: (r.score, r.real_score)) out: List[str] = [] width = 70 out.append("=" * width) out.append("Code Quality Score Report") out.append("=" * width) - out.append("") + + rollup = compute_module_rollup(reports) + if rollup: + out.append("") + out.append( + "Per-module rollup (sorted by average score, worst first):" + ) + out.append(f" {'Module':<40} {'Files':>5} {'Avg':>6} {'Pass':>12}") + out.append("-" * width) + for module, n, avg, passing in rollup: + module_disp = module if len(module) <= 40 else module[-37:] + "..." + pass_str = f"{passing}/{n}" + out.append( + f" {module_disp:<40} {n:>5} {avg:>6.1f} {pass_str:>12}" + ) + out.append("") + out.append(f"{'Score':>6} {'File'}") out.append("-" * width) for r in sorted_reports: - out.append(f"{r.score:>6} {r.path}") + suffix = f" (real_score={r.real_score})" if r.real_score < 0 else "" + out.append(f"{r.score:>6} {r.path}{suffix}") out.append("") for r in sorted_reports: @@ -1217,6 +1309,7 @@ def render_text(reports: List[FileReport], min_score: Optional[int]) -> str: def render_json(reports: List[FileReport], min_score: Optional[int]) -> str: visible = reports if min_score is None else [r for r in reports if r.score <= min_score] + rollup = compute_module_rollup(reports) return json.dumps({ "summary": { "total_scanned": len(reports), @@ -1226,8 +1319,17 @@ def render_json(reports: List[FileReport], min_score: Optional[int]) -> str: ), "passing": sum(1 for r in reports if r.score >= PASS_THRESHOLD), "pass_threshold": PASS_THRESHOLD, + "by_module": [ + { + "module": module, + "file_count": n, + "average_score": avg, + "passing": passing, + } + for module, n, avg, passing in rollup + ], }, - "files": [r.to_dict() for r in sorted(visible, key=lambda r: r.score)], + "files": [r.to_dict() for r in sorted(visible, key=lambda r: (r.score, r.real_score))], }, indent=2) From 763b761d89b6079f9004c70a0621431d4b1407de Mon Sep 17 00:00:00 2001 From: abacus_fixer Date: Sun, 23 Aug 2026 21:54:15 +0800 Subject: [PATCH 08/27] remove C++14 code in diago_pexsi.cpp --- source/source_hsolver/diago_pexsi.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source/source_hsolver/diago_pexsi.cpp b/source/source_hsolver/diago_pexsi.cpp index 525c3b36164..8cbd45cab9f 100644 --- a/source/source_hsolver/diago_pexsi.cpp +++ b/source/source_hsolver/diago_pexsi.cpp @@ -34,7 +34,7 @@ DiagoPexsi::DiagoPexsi(const Parallel_Orbitals* ParaV_in, } this->ParaV = ParaV_in; - this->ps = std::make_unique(); + this->ps.reset(new pexsi::PEXSI_Solver()); this->DM.resize(this->nspin_dm); this->EDM.resize(this->nspin_dm); From 6a22c8c608417b5dd66172f841e630514ef34c94 Mon Sep 17 00:00:00 2001 From: abacus_fixer Date: Sun, 23 Aug 2026 21:57:21 +0800 Subject: [PATCH 09/27] update --- tools/03_code_analysis/code_quality_score.py | 46 +++++++++++--------- 1 file changed, 26 insertions(+), 20 deletions(-) diff --git a/tools/03_code_analysis/code_quality_score.py b/tools/03_code_analysis/code_quality_score.py index b609474c362..862039e5f09 100644 --- a/tools/03_code_analysis/code_quality_score.py +++ b/tools/03_code_analysis/code_quality_score.py @@ -47,9 +47,11 @@ 2. Size, complexity & memory (implementation-level maintainability): - function with more than 7 parameters: -1 per extra param - (cap 30 per file) + (cap 30 per function; multiple over-parameterised functions in + the same file accumulate) - function cyclomatic complexity > 10 (if/for/while/switch/case/ - &&/||): -1 per extra point (cap 30 per file) + &&/||): -1 per extra point (cap 30 per function; multiple + complex functions in the same file accumulate) - file longer than 500 lines: -2 per additional 50-line block (counts all physical lines including blanks and comments; no cap) - member function longer than 50 lines: -1 per additional 50-line @@ -1103,46 +1105,50 @@ def append_capped(rule: str, count: int) -> None: append_capped("unpaired_new_delete", unpaired_new) append_capped("raw_new_keyword", raw_new_count) - # too-many-parameters rule (per-function, capped across the file) + # too-many-parameters rule: each function's deduction is capped + # individually (per-function cap, not per-file). A file with many + # over-parameterised functions accumulates deductions across all of + # them, instead of one bad function hiding the rest. long_param_funcs = find_long_function_signatures(content, FUNCTION_PARAM_THRESHOLD) cap_params = CAPS.get("too_many_parameters") - running_param_deduction = 0 for line_no, fname, pcount in long_param_funcs: excess = pcount - FUNCTION_PARAM_THRESHOLD - per_deduction = excess * WEIGHTS["too_many_parameters"] - if cap_params is not None and running_param_deduction + per_deduction > cap_params: - per_deduction = max(0, cap_params - running_param_deduction) - if per_deduction == 0: - break - running_param_deduction += per_deduction + raw_deduction = excess * WEIGHTS["too_many_parameters"] + if cap_params is not None and raw_deduction > cap_params: + per_deduction = cap_params + cap_text = f" (capped at {cap_params})" + else: + per_deduction = raw_deduction + cap_text = "" findings.append(Finding( rule="too_many_parameters", line=line_no, reason=( f"function '{fname}' has {pcount} parameters " - f"(exceeds {FUNCTION_PARAM_THRESHOLD} by {excess})" + f"(exceeds {FUNCTION_PARAM_THRESHOLD} by {excess}){cap_text}" ), deduction=per_deduction, )) - # high cyclomatic complexity rule (per-function, capped across the file) + # high cyclomatic complexity rule: each function's deduction is capped + # individually (per-function cap, not per-file). high_cyclo_funcs = find_high_complexity_functions(content, CYCLO_THRESHOLD) cap_cyclo = CAPS.get("high_cyclomatic_complexity") - running_cyclo_deduction = 0 for line_no, fname, cyclo in high_cyclo_funcs: excess = cyclo - CYCLO_THRESHOLD - per_deduction = excess * WEIGHTS["high_cyclomatic_complexity"] - if cap_cyclo is not None and running_cyclo_deduction + per_deduction > cap_cyclo: - per_deduction = max(0, cap_cyclo - running_cyclo_deduction) - if per_deduction == 0: - break - running_cyclo_deduction += per_deduction + raw_deduction = excess * WEIGHTS["high_cyclomatic_complexity"] + if cap_cyclo is not None and raw_deduction > cap_cyclo: + per_deduction = cap_cyclo + cap_text = f" (capped at {cap_cyclo})" + else: + per_deduction = raw_deduction + cap_text = "" findings.append(Finding( rule="high_cyclomatic_complexity", line=line_no, reason=( f"function '{fname}' has cyclomatic complexity {cyclo} " - f"(exceeds {CYCLO_THRESHOLD} by {excess})" + f"(exceeds {CYCLO_THRESHOLD} by {excess}){cap_text}" ), deduction=per_deduction, )) From e747810734c6bd29343df0b81019dc2791b84202 Mon Sep 17 00:00:00 2001 From: abacus_fixer Date: Sun, 23 Aug 2026 22:05:42 +0800 Subject: [PATCH 10/27] update --- tools/03_code_analysis/code_quality_score.py | 28 +++++++++++++------- 1 file changed, 18 insertions(+), 10 deletions(-) diff --git a/tools/03_code_analysis/code_quality_score.py b/tools/03_code_analysis/code_quality_score.py index 862039e5f09..5993d543155 100644 --- a/tools/03_code_analysis/code_quality_score.py +++ b/tools/03_code_analysis/code_quality_score.py @@ -39,7 +39,8 @@ - GlobalV::/GlobalC::/PARAM.* cross-layer dependency: -3 per occurrence (cap 10) (AGENTS.md §1) - function declaration with default parameter: -2 per occurrence - (cap 5) (AGENTS.md §5) + (cap 5) (AGENTS.md §5). Detects multi-line declarations where + the parameter list spans lines. - #include of .hpp implementation header: -2 per occurrence (cap 5) (AGENTS.md §3, §4) - each public member variable in a class/struct: -1 @@ -69,7 +70,9 @@ extension, e.g. `matrix_orbs11.cpp` -> stem `matrix_orbs11`) - filename contains uppercase letters: -1 - UPPERCASE constant naming (>3 chars all caps): -1 per occurrence - (cap 5) + (cap 5). Excludes string literals and member accesses such as + `X::UPPER` or `x.UPPER` (those are governed by the + cross-layer-dependency rule or another file's class definition). - tab indentation: -1 per line (cap 5) - `using namespace std;`: -1 per occurrence (cap 5) - line longer than 120 chars: -1 per line (cap 5) @@ -172,7 +175,7 @@ CHINESE_RE = re.compile("[\u4e00-\u9fff]") USING_NS_STD_RE = re.compile(r"\busing\s+namespace\s+std\b") -UPPERCASE_CONST_RE = re.compile(r"\b[A-Z][A-Z0-9_]{2,}\b") +UPPERCASE_CONST_RE = re.compile(r"(? FileReport: chinese_count = sum(1 for l in lines if CHINESE_RE.search(l)) stripped_content = strip_comments(content) - upper_const_count = 0 - for l in stripped_content.split("\n"): - upper_const_count += len(UPPERCASE_CONST_RE.findall(l)) + # uppercase constants: strip strings too (so default-value strings like + # "ABACUS" do not trigger), and the regex excludes member accesses + # (e.g. GlobalV::MY_RANK, x.UPPER) via a negative lookbehind. + stripped_for_upper = strip_strings(stripped_content) + upper_const_count = sum( + len(UPPERCASE_CONST_RE.findall(l)) + for l in stripped_for_upper.split("\n") + ) # interface & dependency rules global_dep_count = len(GLOBAL_DEPENDENCY_RE.findall(stripped_content)) hpp_include_count = sum(1 for l in lines if HPP_INCLUDE_RE.match(l)) friend_count = len(FRIEND_RE.findall(stripped_content)) - # default parameter: scan each stripped line for function-decl signature - default_param_count = 0 - for l in stripped_content.split("\n"): - default_param_count += len(DEFAULT_PARAM_RE.findall(l)) + # default parameter: scan the full stripped content so multi-line + # declarations (parameter list spanning multiple lines) are detected; + # `[^();]*` in the regex already matches newlines. + default_param_count = len(DEFAULT_PARAM_RE.findall(stripped_content)) # unpaired new/delete (file-level): rough heuristic, cap applied below new_count = len(NEW_EXPR_RE.findall(stripped_content)) From 2352078eb49f1f76f56e3dcc6a18ab73590f3c4f Mon Sep 17 00:00:00 2001 From: abacus_fixer Date: Sun, 23 Aug 2026 22:11:53 +0800 Subject: [PATCH 11/27] update --- tools/03_code_analysis/code_quality_score.py | 75 +++++++++++++++++--- 1 file changed, 67 insertions(+), 8 deletions(-) diff --git a/tools/03_code_analysis/code_quality_score.py b/tools/03_code_analysis/code_quality_score.py index 5993d543155..86b7b8ccf36 100644 --- a/tools/03_code_analysis/code_quality_score.py +++ b/tools/03_code_analysis/code_quality_score.py @@ -44,7 +44,11 @@ - #include of .hpp implementation header: -2 per occurrence (cap 5) (AGENTS.md §3, §4) - each public member variable in a class/struct: -1 - - `friend` keyword exposing internals: -1 per occurrence (cap 5) + - each static member variable in a class/struct: -1 (cap 10) + Excludes static_assert, static member functions, and static_cast. + - `friend` keyword exposing internals: -1 per occurrence (cap 5). + Excludes friend declarations to standard-library types (e.g. + `friend class std::hash`, `friend std::ostream& operator<<`). 2. Size, complexity & memory (implementation-level maintainability): - function with more than 7 parameters: -1 per extra param @@ -75,6 +79,7 @@ cross-layer-dependency rule or another file's class definition). - tab indentation: -1 per line (cap 5) - `using namespace std;`: -1 per occurrence (cap 5) + - `goto` keyword: -2 per occurrence (cap 5) - line longer than 120 chars: -1 per line (cap 5) - Chinese characters in comments/code: -1 per line (cap 5) @@ -144,6 +149,8 @@ "high_cyclomatic_complexity": 1, "post_cpp11_feature": 40, "post_cpp11_per_feature": 8, + "goto_keyword": 2, + "static_member_variable": 1, } CAPS = { @@ -161,6 +168,8 @@ "too_many_parameters": 30, "high_cyclomatic_complexity": 30, "post_cpp11_per_feature": 5, + "goto_keyword": 5, + "static_member_variable": 10, } FUNCTION_LENGTH_THRESHOLD = 50 @@ -181,9 +190,10 @@ GLOBAL_DEPENDENCY_RE = re.compile(r"\b(?:GlobalV::|GlobalC::|PARAM(?:\.|->|::))") HPP_INCLUDE_RE = re.compile(r'^\s*#\s*include\s+[<"][^>"]+\.hpp[>"]') -FRIEND_RE = re.compile(r"\bfriend\b") +FRIEND_RE = re.compile(r"\bfriend\b(?!\s+(?:class\s+|struct\s+)?std::)") NEW_EXPR_RE = re.compile(r"\bnew\s+\w") DELETE_EXPR_RE = re.compile(r"\bdelete\s*\[\s*\]?\s+\w") +GOTO_RE = re.compile(r"\bgoto\b") DEFAULT_PARAM_RE = re.compile( r"\b\w+\s*\([^();]*\b\w+\s*=(?![=>])[^();]*\)\s*" @@ -614,6 +624,28 @@ def is_public_member_var(line: str) -> bool: return True +def is_static_member_var(line: str) -> bool: + """Heuristic: does this stripped code line look like a static member + variable declaration inside a class/struct body? + + Targets `static ;` and `static = ...;` + while excluding static member functions, static_assert, and + static_cast (the latter two carry parentheses). + """ + s = line.strip() + if not s.endswith(";"): + return False + if not s.startswith("static "): + return False + if s.startswith("static_assert"): + return False + if "(" in s or ")" in s: + return False + if "{" in s or "}" in s: + return False + return True + + def _match_var_decl(stripped_line: str) -> Optional[str]: """If line looks like a variable declaration `type name;` or `type name = ...;`, return the variable name; else None. @@ -889,13 +921,17 @@ def find_post_cpp11_features( return hits -def analyze_class_blocks(content: str) -> Tuple[List[Finding], List[Finding], List[Finding]]: - """Analyze class/struct blocks for public member variables, long member - functions, and member/local name conflicts. +def analyze_class_blocks( + content: str, +) -> Tuple[List[Finding], List[Finding], List[Finding], List[Finding]]: + """Analyze class/struct blocks for public member variables, static member + variables, long member functions, and member/local name conflicts. - Returns (public_member_findings, long_function_findings, name_conflict_findings). + Returns (public_member_findings, static_member_findings, + long_function_findings, name_conflict_findings). """ pub_findings: List[Finding] = [] + static_findings: List[Finding] = [] long_func_findings: List[Finding] = [] conflict_findings: List[Finding] = [] @@ -949,6 +985,17 @@ def analyze_class_blocks(content: str) -> Tuple[List[Finding], List[Finding], Li deduction=WEIGHTS["public_member_variable"], )) + # static member variable: depth 1, any access section. + # Excludes static_assert, static member functions, and + # static_cast via is_static_member_var's heuristic. + if prev_depth == 1 and is_static_member_var(line): + static_findings.append(Finding( + rule="static_member_variable", + line=abs_line, + reason=f"static member in {kind} {name}: {line.strip()}", + deduction=WEIGHTS["static_member_variable"], + )) + # member/local name conflict: only at depth >= 2 (function body) if prev_depth >= 2: var_name = _match_var_decl(line) @@ -987,7 +1034,7 @@ def analyze_class_blocks(content: str) -> Tuple[List[Finding], List[Finding], Li )) func_start_abs = -1 - return pub_findings, long_func_findings, conflict_findings + return pub_findings, static_findings, long_func_findings, conflict_findings def analyze_file(path: Path) -> FileReport: @@ -1074,6 +1121,7 @@ def analyze_file(path: Path) -> FileReport: global_dep_count = len(GLOBAL_DEPENDENCY_RE.findall(stripped_content)) hpp_include_count = sum(1 for l in lines if HPP_INCLUDE_RE.match(l)) friend_count = len(FRIEND_RE.findall(stripped_content)) + goto_count = len(GOTO_RE.findall(stripped_content)) # default parameter: scan the full stripped content so multi-line # declarations (parameter list spanning multiple lines) are detected; @@ -1112,6 +1160,7 @@ def append_capped(rule: str, count: int) -> None: append_capped("friend_keyword", friend_count) append_capped("unpaired_new_delete", unpaired_new) append_capped("raw_new_keyword", raw_new_count) + append_capped("goto_keyword", goto_count) # too-many-parameters rule: each function's deduction is capped # individually (per-function cap, not per-file). A file with many @@ -1196,8 +1245,18 @@ def append_capped(rule: str, count: int) -> None: )) # class-based rules - pub_findings, long_func_findings, conflict_findings = analyze_class_blocks(content) + ( + pub_findings, + static_findings, + long_func_findings, + conflict_findings, + ) = analyze_class_blocks(content) findings.extend(pub_findings) + # static member findings: cap per file + if len(static_findings) > CAPS.get("static_member_variable", len(static_findings)): + cap_static = CAPS["static_member_variable"] + static_findings = static_findings[:cap_static] + findings.extend(static_findings) findings.extend(long_func_findings) # name conflict findings already respect cap via per-file cap on the rule if len(conflict_findings) > CAPS.get("member_local_name_conflict", len(conflict_findings)): From e5bd52da526107b85796313e5fdb763fe26cc226 Mon Sep 17 00:00:00 2001 From: abacus_fixer Date: Sun, 23 Aug 2026 22:47:16 +0800 Subject: [PATCH 12/27] delete wavefunc_in_pw because they have not been used --- source/Makefile.Objects | 2 +- .../module_wannier/to_wannier90_pw.h | 2 +- source/source_lcao/CMakeLists.txt | 1 - source/source_lcao/module_ri/exx_lip.hpp | 1 - source/source_lcao/wavefunc_in_pw.cpp | 480 ------------------ source/source_lcao/wavefunc_in_pw.h | 46 -- 6 files changed, 2 insertions(+), 530 deletions(-) delete mode 100644 source/source_lcao/wavefunc_in_pw.cpp delete mode 100644 source/source_lcao/wavefunc_in_pw.h diff --git a/source/Makefile.Objects b/source/Makefile.Objects index 860977acfc0..83bd95b9806 100644 --- a/source/Makefile.Objects +++ b/source/Makefile.Objects @@ -471,6 +471,7 @@ OBJS_PSI_INITIALIZER=psi_base.o\ psi_init_atom_rand.o\ psi_init_nao.o\ psi_init_nao_random.o\ + psi_lcao_in_pw.o\ OBJS_PW=fft_bundle.o\ fft_cpu.o\ @@ -691,7 +692,6 @@ OBJS_LCAO=evolve_elec.o\ center2orb_orb21.o\ center2orb_orb22.o\ record_adj.o\ - wavefunc_in_pw.o\ OBJS_MODULE_RI=conv_coulomb_pot_k.o\ exx_abfs-abfs_index.o\ diff --git a/source/source_io/module_wannier/to_wannier90_pw.h b/source/source_io/module_wannier/to_wannier90_pw.h index f2f0c09bda5..6c4bfc23d59 100644 --- a/source/source_io/module_wannier/to_wannier90_pw.h +++ b/source/source_io/module_wannier/to_wannier90_pw.h @@ -14,7 +14,7 @@ #include "source_base/matrix.h" #include "source_base/matrix3.h" #include "source_cell/klist.h" -#include "source_lcao/wavefunc_in_pw.h" +#include "source_basis/module_pw/pw_basis_k.h" #include "source_psi/psi.h" class toWannier90_PW : public toWannier90 diff --git a/source/source_lcao/CMakeLists.txt b/source/source_lcao/CMakeLists.txt index c83afa4af8b..f9e8261ddfd 100644 --- a/source/source_lcao/CMakeLists.txt +++ b/source/source_lcao/CMakeLists.txt @@ -65,7 +65,6 @@ if(ENABLE_LCAO) center2orb_orb11.cpp center2orb_orb21.cpp center2orb_orb22.cpp - wavefunc_in_pw.cpp ) add_library( diff --git a/source/source_lcao/module_ri/exx_lip.hpp b/source/source_lcao/module_ri/exx_lip.hpp index 313958c9a1e..3684b6c6cda 100644 --- a/source/source_lcao/module_ri/exx_lip.hpp +++ b/source/source_lcao/module_ri/exx_lip.hpp @@ -12,7 +12,6 @@ #include "source_base/global_function.h" #include "source_base/vector3.h" #include "source_cell/klist.h" -#include "source_lcao/wavefunc_in_pw.h" #include "source_base/module_external/lapack_connector.h" #include "source_base/parallel_global.h" #include "source_io/module_parameter/parameter.h" diff --git a/source/source_lcao/wavefunc_in_pw.cpp b/source/source_lcao/wavefunc_in_pw.cpp deleted file mode 100644 index 47a0005c385..00000000000 --- a/source/source_lcao/wavefunc_in_pw.cpp +++ /dev/null @@ -1,480 +0,0 @@ -#include // Peize Lin fix bug about strcmp 2016-08-02 -#include -#include "wavefunc_in_pw.h" -#include "source_io/module_parameter/parameter.h" -#include "source_base/math_integral.h" -#include "source_base/math_sphbes.h" -#include "source_base/math_polyint.h" -#include "source_base/math_ylmreal.h" - -void Wavefunc_in_pw::make_table_q( - const UnitCell &ucell, - std::vector &fn, - ModuleBase::realArray &table_local) -{ - ModuleBase::TITLE("Wavefunc_in_pw","make_table_q"); - - if( fn.size() != static_cast(ucell.ntype) ) - { - ModuleBase::WARNING_QUIT( - "Wavefunc_in_pw::make_table_q", - "maybe NUMERICAL_ORBITAL is not read in, please check." - ); - } - - for(int it=0; it> word; - if (std::strcmp(word , "END") == 0) // Peize Lin fix bug about strcmp 2016-08-02 - { - break; - } - } - - ModuleBase::CHECK_NAME(in, "Mesh"); - in >> meshr; - int meshr_read = meshr; - if(meshr%2==0) - { - ++meshr; - } - GlobalV::ofs_running << " meshr=" << meshr; - - ModuleBase::CHECK_NAME(in, "dr"); - in >> dr; - GlobalV::ofs_running << " dr=" << dr; - - std::vector radial(meshr); - std::vector psi(meshr); - std::vector psir(meshr); - std::vector rab(meshr); - - ModuleBase::GlobalFunc::ZEROS(radial.data(), meshr); - ModuleBase::GlobalFunc::ZEROS(psi.data(), meshr); - ModuleBase::GlobalFunc::ZEROS(psir.data(), meshr); - ModuleBase::GlobalFunc::ZEROS(rab.data(), meshr); - for(int ir=0; ir> name1 >> name2 >> name3; - assert( name1 == "Type" ); - in >> tmp_it >> tmp_l >> tmp_n; - if( L == tmp_l && N == tmp_n ) - { - // meshr_read is different from meshr if meshr is even number. - for(int ir=0; ir> psi[ir]; - //psi[ir] = 1.0; //hahaha - psir[ir] = psi[ir] * radial[ir]; - } - find = true; - } - else - { - double no_use = 0.0; - for(int ir=0; ir> no_use; - } - } - } - std::vector table(PARAM.globalv.nqx); - Wavefunc_in_pw::integral( - ucell, meshr, psir.data(), radial.data(), rab.data(), L, table.data()); - for (int iq = 0; iq < PARAM.globalv.nqx; ++iq) - { - //double energy_q = pow(iq * PARAM.globalv.dq,2); - table_local(it, ic, iq) = table[iq];//* Wavefunc_in_pw::smearing(energy_q,150,0.666666); - } - ++ic; - }// N - }// L - }// T - - - if(GlobalV::MY_RANK==0) - { - for(int it=0; it= 1.0 || beta<0 ) - { - ModuleBase::WARNING_QUIT("wavefunc_in_pw::smearing", "beta must between 0 ~ 1 "); - } - - if (energy_x < beta_e) - { - w = 1.0; - } - else if (energy_x >= beta_e && energy_x <= ecut) - { - const double arg = ModuleBase::PI * (ecut - energy_x) * 0.5 / (1-beta) / ecut ; - // const double sin_arg = sin(arg); // gong 2009. 7. 12 , correct - // w = sin_arg*sin_argi ; - w = 0.5 * (1 - cos(2.0 * arg)); - } - else if (energy_x > ecut) - { - w = 0.0 ; - } - - return w ; -} - - -void Wavefunc_in_pw::integral(const UnitCell& ucell, - const int meshr, - const double *psir, - const double *r, - const double *rab, - const int &l, - double* table) -{ - const double pref = ModuleBase::FOUR_PI / sqrt(ucell.omega); - - std::vector inner_part(meshr); - for (int ir = 0; ir < meshr; ++ir) - { - inner_part[ir] = psir[ir] * psir[ir]; - } - - double unit = 0.0; - ModuleBase::Integral::Simpson_Integral(meshr, inner_part.data(), rab, unit); - ModuleBase::GlobalFunc::OUT(GlobalV::ofs_running, "normalize unit", unit); - - std::vector aux(meshr); - std::vector vchi(meshr); - for (int iq = 0; iq < PARAM.globalv.nqx; ++iq) - { - const double q = PARAM.globalv.dq * iq; - ModuleBase::Sphbes::Spherical_Bessel(meshr, r, q, l, aux.data()); - for (int ir = 0; ir < meshr; ++ir) - { - vchi[ir] = psir[ir] * aux[ir] * r[ir]; - } - - double vqint = 0.0; - ModuleBase::Integral::Simpson_Integral(meshr, vchi.data(), rab, vqint); - - table[iq] = vqint * pref; - } - return; -} - -void Wavefunc_in_pw::produce_local_basis_in_pw(const UnitCell& ucell, - const int& ik, - const ModulePW::PW_Basis_K* wfc_basis, - const Structure_Factor& sf, - ModuleBase::ComplexMatrix& psi, - const ModuleBase::realArray& table_local) -{ - ModuleBase::TITLE("Wavefunc_in_pw","produce_local_basis_in_pw"); - assert(ik>=0); - const int npw = wfc_basis->npwk[ik]; - const int total_lm = ( ucell.lmax + 1) * ( ucell.lmax + 1); - ModuleBase::matrix ylm(total_lm, npw); - std::vector> aux(npw); - std::vector chiaux; - bool chiaux_init = false; - - std::vector> gk(npw); - for (int ig = 0; ig < npw; ++ig) - { - gk[ig] = wfc_basis->getgpluskcar(ik, ig); - } - - ModuleBase::YlmReal::Ylm_Real(total_lm, npw, gk.data(), ylm); - - //int index = 0; - std::vector flq(npw); - int iwall=0; - for (int it = 0;it < ucell.ntype;it++) - { - for (int ia = 0;ia < ucell.atoms[it].na;ia++) - { - std::complex* sk = sf.get_sk(ik, it, ia, wfc_basis); - int ic = 0; - for(int L = 0; L < ucell.atoms[it].nwl+1; L++) - { - std::complex lphase = pow(ModuleBase::NEG_IMAG_UNIT, L); //mohan 2010-04-19 - for(int N=0; N < ucell.atoms[it].l_nchi[L]; N++) - { -// GlobalV::ofs_running << " it=" << it << " ia=" << ia << " L=" << L << " N=" << N << std::endl; - - for(int ig=0; ignpwk_max) - = lphase * sk[ig] * ylm(lm, ig) * flq[ig]; - } - iwall += 2; - } - }//if - else - {//atomic_wfc_so_mag - double alpha = 0.0, gamma = 0.0; - std::complex fup,fdown; - //int nc; - // This routine creates two functions only - // in the case j=l+1/2 or exit otherwise - if(fabs(j-L+0.5)<1e-4) { continue; -} - if (!chiaux_init) - { - chiaux.resize(npw); - chiaux_init = true; - } - //Find the functions j= l- 1/2 - if(L==0) { - for(int ig=0;ig ucell.natomwfc) - { - ModuleBase::WARNING_QUIT("this->wf.atomic_wfc()", "error: too many wfcs"); - } - for (int ig = 0; ig < npw; ig++) - { - aux[ig] = sk[ig] * ylm(lm,ig) * chiaux[ig]; - } - //rotate wfc as needed - //first rotation with angle alpha around (OX) - for(int ig = 0;ignpwk_max) - = (cos(0.5 * gamma) - ModuleBase::IMAG_UNIT * sin(0.5 * gamma)) * fdown; - // second rotation with angle gamma around(OZ) - fup = cos(0.5 * (alpha + ModuleBase::PI)) * aux[ig]; - fdown = ModuleBase::IMAG_UNIT * sin(0.5 * (alpha + ModuleBase::PI))*aux[ig]; - psi(iwall + 2 * L + 1, ig) = - (cos(0.5 * gamma) + ModuleBase::IMAG_UNIT * sin(0.5 * gamma)) - * fup; - psi(iwall + 2 * L + 1, ig + wfc_basis->npwk_max) - = (cos(0.5 * gamma) - ModuleBase::IMAG_UNIT * sin(0.5 * gamma)) * fdown; - } - iwall++; - } - iwall += 2*L +1; - } // end else INPUT.starting_spin_angle || !PARAM.globalv.domag - } // end if ucell.atoms[it].has_so - else - {//atomic_wfc_nc - double alpha = 0.0, gamman = 0.0; - std::complex fup = 0.0, fdown = 0.0; - alpha = ucell.atoms[it].angle1[ia]; - gamman = -ucell.atoms[it].angle2[ia] + 0.5*ModuleBase::PI; - for(int m = 0;m<2*L+1;m++) - { - const int lm = L*L +m; - if (iwall + 2 * L + 1 > ucell.natomwfc) - { - ModuleBase::WARNING_QUIT("this->wf.atomic_wfc()", "error: too many wfcs"); - } - for (int ig = 0; ig < npw; ig++) - { - aux[ig] = sk[ig] * ylm(lm,ig) * flq[ig]; - } - //rotate function - //first, rotation with angle alpha around(OX) - for(int ig = 0;ignpwk_max) - = (cos(0.5 * gamman) - ModuleBase::IMAG_UNIT * sin(0.5 * gamman)) * fdown; - // second rotation with angle gamma around(OZ) - fup = cos(0.5 * (alpha + ModuleBase::PI)) * aux[ig]; - fdown = ModuleBase::IMAG_UNIT * sin(0.5 * (alpha + ModuleBase::PI)) * aux[ig]; - psi(iwall + 2 * L + 1, ig) = - (cos(0.5 * gamman) + ModuleBase::IMAG_UNIT * sin(0.5 * gamman)) - * fup; - psi(iwall + 2 * L + 1, ig + wfc_basis->npwk_max) - = (cos(0.5 * gamman) - ModuleBase::IMAG_UNIT * sin(0.5 * gamman)) * fdown; - } // end ig - iwall++; - } // end m - iwall += 2*L+1; - } // end else ucell.atoms[it].has_so - } // end for is_N - } // end if PARAM.inp.noncolin - else - {//LSDA and nomagnet case - for(int m=0; m<2*L+1; m++) - { - const int lm = L*L+m; - for(int ig=0; ig &orbital_files, - ModuleBase::realArray &table_local); - - void integral( - const UnitCell& ucell, - const int meshr, // number of mesh points - const double *psir, - const double *r, - const double *rab, - const int &l, - double* table); - - //mohan add 2010-04-20 - double smearing( - const double &energy_x, - const double &ecut, - const double &beta); - - void produce_local_basis_in_pw(const UnitCell& ucell, - const int& ik, - const ModulePW::PW_Basis_K* wfc_basis, - const Structure_Factor& sf, - ModuleBase::ComplexMatrix& psi, - const ModuleBase::realArray& table_local); - -} -#endif From a3ed9bae8a116d2859f3e44a4c95b2ce0189c939 Mon Sep 17 00:00:00 2001 From: abacus_fixer Date: Sun, 23 Aug 2026 22:47:32 +0800 Subject: [PATCH 13/27] update makefile --- source/Makefile.Objects | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/source/Makefile.Objects b/source/Makefile.Objects index 83bd95b9806..ec8281204d2 100644 --- a/source/Makefile.Objects +++ b/source/Makefile.Objects @@ -470,8 +470,7 @@ OBJS_PSI_INITIALIZER=psi_base.o\ psi_init_atomic.o\ psi_init_atom_rand.o\ psi_init_nao.o\ - psi_init_nao_random.o\ - psi_lcao_in_pw.o\ + psi_init_nao_random.o OBJS_PW=fft_bundle.o\ fft_cpu.o\ From d472cce2cd66372a7145afebf561de4d61b5e71a Mon Sep 17 00:00:00 2001 From: abacus_fixer Date: Sun, 23 Aug 2026 22:47:57 +0800 Subject: [PATCH 14/27] remove C++14 codes in tests --- source/source_basis/module_ao/test/orb_test.cpp | 2 +- source/source_hsolver/test/diago_bpcg_test.cpp | 4 ++-- source/source_hsolver/test/diago_pexsi_test.cpp | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/source/source_basis/module_ao/test/orb_test.cpp b/source/source_basis/module_ao/test/orb_test.cpp index 37bd4a72bec..63f41522a19 100644 --- a/source/source_basis/module_ao/test/orb_test.cpp +++ b/source/source_basis/module_ao/test/orb_test.cpp @@ -213,7 +213,7 @@ void test_orb::set_single_c2o(int TA, int TB, int LA, int NA, int LB, int NB) { this->test_center2_orb11[TA][TB][LA][NA][LB].insert(std::make_pair( NB, - std::make_unique(ORB.Phi[TA].PhiLN(LA, NA), ORB.Phi[TB].PhiLN(LB, NB), OGT.MOT.pSB, Center2_MGT))); + std::unique_ptr(new c2o(ORB.Phi[TA].PhiLN(LA, NA), ORB.Phi[TB].PhiLN(LB, NB), OGT.MOT.pSB, Center2_MGT)))); } double test_orb::randr(double Rmax) { diff --git a/source/source_hsolver/test/diago_bpcg_test.cpp b/source/source_hsolver/test/diago_bpcg_test.cpp index 7b07f3e3996..ee0b8f4aab2 100644 --- a/source/source_hsolver/test/diago_bpcg_test.cpp +++ b/source/source_hsolver/test/diago_bpcg_test.cpp @@ -136,8 +136,8 @@ class DiagoBPCGPrepare const std::vector &h_mat = DIAGOTEST::hmatrix_local; auto hpsi_func = [h_mat, dim](T *psi_in, T *hpsi_out, const int ld_psi, const int nvec) { - auto one = std::make_unique(1.0); - auto zero = std::make_unique(0.0); + std::unique_ptr one(new T(1.0)); + std::unique_ptr zero(new T(0.0)); const T *one_ = one.get(); const T *zero_ = zero.get(); diff --git a/source/source_hsolver/test/diago_pexsi_test.cpp b/source/source_hsolver/test/diago_pexsi_test.cpp index 91b0bbaffbb..7523a1d5f26 100644 --- a/source/source_hsolver/test/diago_pexsi_test.cpp +++ b/source/source_hsolver/test/diago_pexsi_test.cpp @@ -160,7 +160,7 @@ class PexsiPrepare std::cout << "nrow: " << hmtest.nrow << ", ncol: " << hmtest.ncol << ", nb: " << nb2d << std::endl; } - dh = std::make_unique>(&po, PARAM.input.nspin, nlocal, PARAM.input.nelec); + dh.reset(new hsolver::DiagoPexsi(&po, PARAM.input.nspin, nlocal, PARAM.input.nelec)); } void distribute_data() From 1cbf76b4b7f481176e31a6fbdd638ab0baeb76bb Mon Sep 17 00:00:00 2001 From: abacus_fixer Date: Mon, 24 Aug 2026 08:46:41 +0800 Subject: [PATCH 15/27] remove using namespace std in psi_base.h --- source/source_lcao/module_ri/exx_lip.hpp | 30 ++++++++++---------- source/source_psi/psi_base.h | 2 -- tools/03_code_analysis/code_quality_score.py | 4 +-- 3 files changed, 17 insertions(+), 19 deletions(-) diff --git a/source/source_lcao/module_ri/exx_lip.hpp b/source/source_lcao/module_ri/exx_lip.hpp index 3684b6c6cda..c5cb36b27a2 100644 --- a/source/source_lcao/module_ri/exx_lip.hpp +++ b/source/source_lcao/module_ri/exx_lip.hpp @@ -324,14 +324,14 @@ void Exx_Lip::qkg2_exp(const int ik, const int iq) else { this->recip_qkg2[ig] = 1.0 / qkg2; } this->sum2_factor += this->recip_qkg2[ig] * std::exp(-info.lambda * qkg2); - this->recip_qkg2[ig] = sqrt(this->recip_qkg2[ig]); + this->recip_qkg2[ig] = std::sqrt(this->recip_qkg2[ig]); } else if (Conv_Coulomb_Pot_K::Ccp_Type::Erfc == info.ccp_type) { if (std::abs(qkg2) < 1e-10) { this->recip_qkg2[ig] = 1.0 / (2 * info.hse_omega); } else - { this->recip_qkg2[ig] = sqrt((1 - std::exp(-qkg2 / (4 * info.hse_omega * info.hse_omega))) / qkg2); } + { this->recip_qkg2[ig] = std::sqrt((1 - std::exp(-qkg2 / (4 * info.hse_omega * info.hse_omega))) / qkg2); } } else { @@ -347,13 +347,13 @@ void Exx_Lip::b_cal(const int ik, const int iq, const int ib) ModuleBase::timer::start("Exx_Lip", "b_cal"); const ModuleBase::Vector3 q_minus_k = this->q_pack->kv_ptr->kvec_d[iq] - this->k_pack->kv_ptr->kvec_d[ik]; std::vector mul_tmp(this->rho_basis->nrxx); - for( size_t ir=0,ix=0; ixrho_basis->nx; ++ix) + for( std::size_t ir=0,ix=0; ixrho_basis->nx; ++ix) { const Treal phase_x = q_minus_k.x * ix / this->rho_basis->nx; - for( size_t iy=0; iyrho_basis->ny; ++iy) + for( std::size_t iy=0; iyrho_basis->ny; ++iy) { const Treal phase_xy = phase_x + q_minus_k.y * iy / this->rho_basis->ny; - for( size_t iz=this->rho_basis->startz_current; izrho_basis->startz_current+this->rho_basis->nplane; ++iz) + for( std::size_t iz=this->rho_basis->startz_current; izrho_basis->startz_current+this->rho_basis->nplane; ++iz) { const Treal phase_xyz = phase_xy + q_minus_k.z * iz / this->rho_basis->nz; mul_tmp[ir] = std::exp(-phase_xyz * this->two_pi_i); @@ -364,12 +364,12 @@ void Exx_Lip::b_cal(const int ik, const int iq, const int ib) } std::vector porter (this->rho_basis->nrxx); - for(size_t iw=0; iw< PARAM.globalv.nlocal; ++iw) + for(std::size_t iw=0; iw< PARAM.globalv.nlocal; ++iw) { auto& phi_w = this->phi[iw]; - for( size_t ir=0; irrho_basis->nrxx; ++ir) + for( std::size_t ir=0; irrho_basis->nrxx; ++ir) { - porter[ir] = conj(phi_w[ir]) * mul_tmp[ir] ; + porter[ir] = std::conj(phi_w[ir]) * mul_tmp[ir] ; // porter[ir] = phi_w[ir] * psi_q_b[ir] *exp_tmp[ir] ; } T* const b_w = &this->b[iw * this->rho_basis->npw]; @@ -379,7 +379,7 @@ void Exx_Lip::b_cal(const int ik, const int iq, const int ib) this->b0[iw] = b_w[this->rho_basis->ig_gge0]; } } - for (size_t ig = 0; ig < this->rho_basis->npw; ++ig) + for (std::size_t ig = 0; ig < this->rho_basis->npw; ++ig) { b_w[ig] *= this->recip_qkg2[ig]; } } ModuleBase::timer::end("Exx_Lip", "b_cal"); @@ -392,7 +392,7 @@ void Exx_Lip::sum3_cal(const int iq, const int ib) if (gzero_rank_in_pool == GlobalV::RANK_IN_POOL) { for (int iw_l = 0; iw_l < PARAM.globalv.nlocal; ++iw_l) { for (int iw_r = 0; iw_r < PARAM.globalv.nlocal; ++iw_r) { - this->sum3[iw_l][iw_r] += this->b0[iw_l] * conj(this->b0[iw_r]) * (Treal)this->q_pack->wf_wg(iq, ib); + this->sum3[iw_l][iw_r] += this->b0[iw_l] * std::conj(this->b0[iw_r]) * (Treal)this->q_pack->wf_wg(iq, ib); } } } ModuleBase::timer::end("Exx_Lip", "sum3_cal"); } @@ -425,9 +425,9 @@ void Exx_Lip::sum_all(const int ik) if (Conv_Coulomb_Pot_K::Ccp_Type::Ccp == info.ccp_type || Conv_Coulomb_Pot_K::Ccp_Type::Hf == info.ccp_type) { MPI_Reduce(&this->sum2_factor, &sum2_factor_g, 1, MPI_DOUBLE, MPI_SUM, gzero_rank_in_pool, POOL_WORLD); } #endif - for (size_t iw_l = 1; iw_l < PARAM.globalv.nlocal; ++iw_l) { - for (size_t iw_r = 0; iw_r < iw_l; ++iw_r) { - this->sum1[iw_l * PARAM.globalv.nlocal + iw_r] = conj(this->sum1[iw_r * PARAM.globalv.nlocal + iw_l]); // Peize Lin add conj 2019-04-14 + for (std::size_t iw_l = 1; iw_l < PARAM.globalv.nlocal; ++iw_l) { + for (std::size_t iw_r = 0; iw_r < iw_l; ++iw_r) { + this->sum1[iw_l * PARAM.globalv.nlocal + iw_r] = std::conj(this->sum1[iw_r * PARAM.globalv.nlocal + iw_l]); // Peize Lin add conj 2019-04-14 } } for (int iw_l = 0; iw_l < PARAM.globalv.nlocal; ++iw_l) @@ -440,7 +440,7 @@ void Exx_Lip::sum_all(const int ik) if (gzero_rank_in_pool == GlobalV::RANK_IN_POOL) { this->exx_matrix[ik][iw_l][iw_r] += spin_fac * (fourpi_div_omega * this->sum3[iw_l][iw_r] * sum2_factor_g); - this->exx_matrix[ik][iw_l][iw_r] += spin_fac * (-1 / (Treal)sqrt(info.lambda * ModuleBase::PI) * (Treal)(this->q_pack->kv_ptr->get_nks() / PARAM.inp.nspin) * this->sum3[iw_l][iw_r]); + this->exx_matrix[ik][iw_l][iw_r] += spin_fac * (-1 / (Treal)std::sqrt(info.lambda * ModuleBase::PI) * (Treal)(this->q_pack->kv_ptr->get_nks() / PARAM.inp.nspin) * this->sum3[iw_l][iw_r]); } } } @@ -460,7 +460,7 @@ void Exx_Lip::exx_energy_cal() for( int iw_l=0; iw_lexx_matrix[ik][iw_l][iw_r] * conj((*this->k_pack->hvec_array)(ik, ib, iw_l)) * (*this->k_pack->hvec_array)(ik, ib, iw_r)).real() * this->k_pack->wf_wg(ik, ib); + exx_energy_tmp += (this->exx_matrix[ik][iw_l][iw_r] * std::conj((*this->k_pack->hvec_array)(ik, ib, iw_l)) * (*this->k_pack->hvec_array)(ik, ib, iw_r)).real() * this->k_pack->wf_wg(ik, ib); } } } } #ifdef __MPI MPI_Allreduce( &exx_energy_tmp, &this->exx_energy, 1, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD); // !!! k_point parallel incompleted. different pools have different kv.set_nks(>) deadlock diff --git a/source/source_psi/psi_base.h b/source/source_psi/psi_base.h index c13a2b5d288..212065ee21f 100644 --- a/source/source_psi/psi_base.h +++ b/source/source_psi/psi_base.h @@ -14,8 +14,6 @@ namespace ModulePW { class PW_Basis_K; } class Structure_Factor; class UnitCell; -using namespace std; - /* Psi (planewave based wavefunction) base class Auther: Kirk0830 diff --git a/tools/03_code_analysis/code_quality_score.py b/tools/03_code_analysis/code_quality_score.py index 86b7b8ccf36..9b4caa8cfc5 100644 --- a/tools/03_code_analysis/code_quality_score.py +++ b/tools/03_code_analysis/code_quality_score.py @@ -13,7 +13,7 @@ - All caps listed below are per-file limits on the cumulative deduction for that rule within a single file. - Files under any of these directories are skipped entirely: test/, - tests/, test_serial/, test_parallel/, unit_test/, unittest/. + tests/, test_serial/, test_parallel/, test_gpu/, unit_test/, unittest/. - Pass threshold: score >= 60. Output is sorted by score ascending (worst files first); ties are broken by `real_score` ascending (more negative = more total deduction = ranked first). Text and @@ -109,7 +109,7 @@ ".git", "build", "__pycache__", "node_modules", ".cache", "third_party", "thirdparty", ".vscode", ".idea", ".trae-cn", "Dependencies", - "test", "tests", "test_serial", "test_parallel", "unit_test", "unittest", + "test", "tests", "test_serial", "test_parallel", "test_gpu", "unit_test", "unittest", } CAPS = { From be3bc28c1bd17fa6d9fd9e401315fefdd80e9fa6 Mon Sep 17 00:00:00 2001 From: abacus_fixer Date: Mon, 24 Aug 2026 09:04:26 +0800 Subject: [PATCH 16/27] remove Chinese notes --- source/source_hsolver/kernels/cuda/diag_cusolvermp.cu | 2 +- source/source_io/module_unk/berryphase.cpp | 4 ++-- source/source_lcao/module_deltaspin/spin_constrain.cpp | 2 +- source/source_lcao/module_ri/rpa_lri.hpp | 2 +- source/source_lcao/module_rt/solve_propagation.cpp | 2 +- 5 files changed, 6 insertions(+), 6 deletions(-) diff --git a/source/source_hsolver/kernels/cuda/diag_cusolvermp.cu b/source/source_hsolver/kernels/cuda/diag_cusolvermp.cu index 20c4bb35e52..c8fd9e8f066 100644 --- a/source/source_hsolver/kernels/cuda/diag_cusolvermp.cu +++ b/source/source_hsolver/kernels/cuda/diag_cusolvermp.cu @@ -58,7 +58,7 @@ Diag_CusolverMP_gvd::Diag_CusolverMP_gvd(const MPI_Comm mpi_comm, const int nacols, const int* desc) { - // 构造函数的实现 + /// constructor implementation this->cblacs_ctxt = desc[1]; this->nFull = desc[2]; diff --git a/source/source_io/module_unk/berryphase.cpp b/source/source_io/module_unk/berryphase.cpp index a41ef3f6bd0..e06f58861d4 100644 --- a/source/source_io/module_unk/berryphase.cpp +++ b/source/source_io/module_unk/berryphase.cpp @@ -113,7 +113,7 @@ void berryphase::set_kpoints(const K_Vectors& kv, const int direction) nppstr = mp_x + 1; } - else if (direction == 2) // 计算y方向 + else if (direction == 2) /// compute the y direction { const int num_string = mp_x * mp_z; @@ -163,7 +163,7 @@ void berryphase::set_kpoints(const K_Vectors& kv, const int direction) nppstr = mp_y + 1; } - else if (direction == 3) // 计算z方向 + else if (direction == 3) /// compute the z direction { const int num_string = mp_x * mp_y; diff --git a/source/source_lcao/module_deltaspin/spin_constrain.cpp b/source/source_lcao/module_deltaspin/spin_constrain.cpp index df8b4b20b35..5950cc04d9e 100644 --- a/source/source_lcao/module_deltaspin/spin_constrain.cpp +++ b/source/source_lcao/module_deltaspin/spin_constrain.cpp @@ -825,7 +825,7 @@ void SpinConstrain::print_Mi(std::ofstream& ofs_running) * @par Typical values * - Well-converged SCF: lambda ~ 0.01-1 eV/uB * - Strongly constrained: lambda ~ 1-10 eV/uB - * - Diverging SCF: lambda growing without bound (check target_mag合理性) + * - Diverging SCF: lambda growing without bound (check target_mag validity) */ template void SpinConstrain::print_Mag_Force(std::ofstream& ofs_running) diff --git a/source/source_lcao/module_ri/rpa_lri.hpp b/source/source_lcao/module_ri/rpa_lri.hpp index 7a5f7fb5fe0..c2fa83ce8cc 100644 --- a/source/source_lcao/module_ri/rpa_lri.hpp +++ b/source/source_lcao/module_ri/rpa_lri.hpp @@ -1517,7 +1517,7 @@ void RPA_LRI::out_velocity(const UnitCell &ucell, // list_As_Vs.first, list_As_Vs.second[0], // {{"writable_Vws",true}}); -// // Vs[iat0][{iat1,cell1}] 按 (iat0,iat1) 分进程，每个进程有所有 cell1 +// // Vs[iat0][{iat1,cell1}] distributed across processes by (iat0,iat1); each process holds all cell1 // Vqs = FFT(Vs); // out_Vs(Vqs); diff --git a/source/source_lcao/module_rt/solve_propagation.cpp b/source/source_lcao/module_rt/solve_propagation.cpp index aa0a9f38371..ed29f36490c 100644 --- a/source/source_lcao/module_rt/solve_propagation.cpp +++ b/source/source_lcao/module_rt/solve_propagation.cpp @@ -83,7 +83,7 @@ void solve_propagation(const Parallel_Orbitals* pv, const double dt, const std::complex* Stmp, const std::complex* Htmp, - const std::complex* P_k, // <--- 接收 P_k + const std::complex* P_k, ///< receives P_k const std::complex* psi_k_laststep, std::complex* psi_k) { From 08c9aa497bce76c3e2746a9bdf0eea0a7f476522 Mon Sep 17 00:00:00 2001 From: abacus_fixer Date: Mon, 24 Aug 2026 09:09:44 +0800 Subject: [PATCH 17/27] remove one duplicate name of variables --- source/source_pw/module_stodft/sto_tool.h | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/source/source_pw/module_stodft/sto_tool.h b/source/source_pw/module_stodft/sto_tool.h index 6b0c9e2a59c..a2eaf2a00bb 100644 --- a/source/source_pw/module_stodft/sto_tool.h +++ b/source/source_pw/module_stodft/sto_tool.h @@ -38,12 +38,12 @@ struct parallel_distribution { parallel_distribution(const int& num_all, const int& np, const int myrank) { - int num_per = num_all / np; - int st_per = num_per * myrank; + int num_per_ = num_all / np; + int st_per = num_per_ * myrank; int re = num_all % np; if (myrank < re) { - ++num_per; + ++num_per_; st_per += myrank; } else @@ -51,7 +51,7 @@ struct parallel_distribution st_per += re; } this->start = st_per; - this->num_per = num_per; + this->num_per = num_per_; } int start = 0; int num_per = 0; From 375ab5826949a0e3402f3eb7d8d39c0f71e68c60 Mon Sep 17 00:00:00 2001 From: abacus_fixer Date: Tue, 25 Aug 2026 07:25:59 +0800 Subject: [PATCH 18/27] fix(code_quality): exclude template type params and enum class in find_class_blocks - Reject 'class T' / 'struct T' appearing inside template parameter lists (preceded by '<' or ',' after skipping whitespace), preventing the enclosing function body from being misidentified as a class body. - Reject 'enum class' / 'enum struct' scoped enumerations by checking backwards for the 'enum' keyword with optional intervening whitespace. - Update docstring to document the two exclusion cases. Reproducers fixed: template -> no longer returns [(1, 5, 'class', 'T')] enum class Kind {} -> no longer treated as class block 'Kind' --- tools/03_code_analysis/code_quality_score.py | 21 ++++++++++++++++++++ 1 file changed, 21 insertions(+) diff --git a/tools/03_code_analysis/code_quality_score.py b/tools/03_code_analysis/code_quality_score.py index 9b4caa8cfc5..1e3739d3db7 100644 --- a/tools/03_code_analysis/code_quality_score.py +++ b/tools/03_code_analysis/code_quality_score.py @@ -521,6 +521,7 @@ def find_class_blocks(code: str) -> List[Tuple[int, int, str, str]]: (start_line_1indexed, end_line_1indexed, kind, name). Walks brace matching starting from each `class X {` / `struct X {` opener. + Excludes `template ` type parameters and `enum class` scoped enums. """ blocks: List[Tuple[int, int, str, str]] = [] i = 0 @@ -529,6 +530,26 @@ def find_class_blocks(code: str) -> List[Tuple[int, int, str, str]]: m = CLASS_OPEN_RE.search(code, i) if not m: break + # reject template type parameters: `template ` or `<..., class T, ...>` + # look at non-whitespace chars before the match + pre_start = m.start() - 1 + while pre_start >= 0 and code[pre_start] in " \t\n\r": + pre_start -= 1 + if pre_start >= 0 and code[pre_start] in "<,": + i = m.end() + continue + # reject `enum class` / `enum struct` scoped enumerations + # look backwards for `enum` keyword (with optional whitespace) + enum_check_pos = pre_start + while enum_check_pos >= 0 and code[enum_check_pos] in " \t\n\r": + enum_check_pos -= 1 + if ( + enum_check_pos >= 3 + and code[enum_check_pos - 3:enum_check_pos + 1].lower() == "enum" + and (enum_check_pos == 3 or not code[enum_check_pos - 4].isalnum()) + ): + i = m.end() + continue # find the opening brace after the class/struct header # allow inheritance clauses: class X : public Y { ... } brace_pos = code.find("{", m.end()) From d4b53d3bbc2703c87b889c6a609c769fd5f93ea9 Mon Sep 17 00:00:00 2001 From: abacus_fixer Date: Tue, 25 Aug 2026 07:39:12 +0800 Subject: [PATCH 19/27] fix(code_quality): handle trailing return type and ctor init list in fn scan Add two helpers to advance past post-parameter-list suffixes before the caller looks for function terminators (;, {, =): * _skip_trailing_return_type: advances over '-> ReturnType' including qualified and templated types such as std::vector and int (*)(int). Stops at the first terminator / qualifier keyword encountered at bracket depth 0. ':' is NOT treated as a terminator so scope-resolution '::' inside the return type is preserved. * _skip_member_initializer_list: advances over ': a(x), b{1,2}' constructor member initializer lists. Distinguishes a member brace-init 'a{...}' from the actual function-body opener at depth 0 by looking at the previous non-whitespace char: when the prior char is ')', '}', ',' or ':' the '{' is the function body and scanning stops; otherwise it is a member brace-init and depth is increased normally. Refactor post-')' scanning in both find_long_function_signatures and find_function_bodies to use a loop that consumes qualifiers, the trailing-return type (via helper), and the member initializer list (via helper) in any valid order before looking for terminators. The initializer-list ':' is additionally guarded to ensure it is preceded by the closing parameter paren (prevents 'Foo::Bar()' from being treated as an init list). Reproducers fixed: auto f(int x) -> int { ... } -> now reported as body 'f' A::A(int x) : x_(x) { ... } -> now reported as ctor 'A' (not 'x_') --- tools/03_code_analysis/code_quality_score.py | 183 +++++++++++++++++-- 1 file changed, 166 insertions(+), 17 deletions(-) diff --git a/tools/03_code_analysis/code_quality_score.py b/tools/03_code_analysis/code_quality_score.py index 1e3739d3db7..d17dd5dff28 100644 --- a/tools/03_code_analysis/code_quality_score.py +++ b/tools/03_code_analysis/code_quality_score.py @@ -681,6 +681,102 @@ def _match_var_decl(stripped_line: str) -> Optional[str]: return m.group(1) if m else None +def _skip_trailing_return_type(s: str, start: int) -> int: + """Advance past `-> ReturnType` starting at position `start`. + + `start` must point at the `-` in `->`. Scans over the return type by + tracking bracket nesting; stops and returns the position of the first + post-type character. Recognises two stop conditions at depth 0: + + (a) current char is a direct terminator (`;`, `{`, `=`) or a + qualifier keyword starts here — stop on the spot so the caller + consumes it on the next loop iteration. + (b) current char is whitespace followed by a terminator or qualifier + keyword — stop at the whitespace position so the caller's own + whitespace-skip advances past it cleanly. + + `:` is NOT a terminator because qualified return types like + `std::vector` contain `::` scope-resolution colons, and in any + case a trailing-return-type function cannot also be a constructor + (which is the only case that introduces a member initializer list). + + Caller re-runs qualifier / suffix scanning after this helper returns. + """ + i = start + 2 # skip past `->` + n = len(s) + # skip whitespace between `->` and the type + while i < n and s[i] in " \t\n": + i += 1 + depth = 0 + while i < n: + c = s[i] + if c in "([{<": + depth += 1 + elif c in ")]}>": + depth = max(0, depth - 1) + if depth == 0: + # (a) terminator/qualifier attached directly to the type, e.g. `int;` + if c in ";{=": + break + if QUALIFIER_RE.match(s, i): + break + # (b) terminator/qualifier after whitespace, e.g. `int const` / `int ;` + if c in " \t\n": + next_word_start = i + 1 + while next_word_start < n and s[next_word_start] in " \t\n": + next_word_start += 1 + if next_word_start >= n: + break + nc = s[next_word_start] + if nc in ";{=": + break + if QUALIFIER_RE.match(s, next_word_start): + break + i += 1 + return i + + +def _skip_member_initializer_list(s: str, start: int) -> int: + """Advance past `: member(args), member{args}, ...` constructor initializer + list starting at position `start`. + + `start` must point at the `:` that introduces the list (and be preceded by + `)` — caller ensures this is not a `::` scope-resolution colon). Scans + commas between members while respecting nesting; returns the position of + the opening `{` (or `;`, `=`, or end-of-string if body-less). + + Heuristic: at depth 0, `{` can either open a brace-initializer for a + member (e.g. `a{1,2}`) or open the function body itself. The function + body `{` is distinguished by looking at the previous non-whitespace + character: if it is `)` or `}` (a previous initializer ended normally) + or `,` / `:` (list-level punctuation), then `{` belongs to the function + body and scanning stops. Otherwise the `{` is consumed as a member + brace-initializer (depth increases normally). + """ + i = start + 1 # skip past `:` + n = len(s) + depth = 0 + while i < n: + c = s[i] + # Decide `{` at depth 0 before bumping depth. + if depth == 0 and c == "{": + prev = i - 1 + while prev >= 0 and s[prev] in " \t\n": + prev -= 1 + prev_c = s[prev] if prev >= 0 else "" + # `{` after full initializer / separator = function body opener + if prev_c in ")}:,": + break + if c in "([{<": + depth += 1 + elif c in ")]}>": + depth = max(0, depth - 1) + if depth == 0 and c in ";=": + break + i += 1 + return i + + def count_function_params(params_str: str) -> int: """Count top-level parameters by counting commas at bracket depth 0. @@ -771,23 +867,50 @@ def find_long_function_signatures( continue params_str = stripped[paren_open + 1:j] - # after `)`: optional qualifiers (const/override/final/noexcept), then ; { or = - after = stripped[j + 1:].lstrip() - k = 0 + # after `)`: optional qualifiers (const/override/final/noexcept), + # optional trailing-return type (`-> ReturnType`), optional + # constructor member initializer list (`: a(x), b{y}`), then ; { or = + pos = j + 1 + while pos < n and stripped[pos] in " \t\n": + pos += 1 while True: - mq = QUALIFIER_RE.match(after, k) - if not mq: - break - k = mq.end() - while k < len(after) and after[k] in " \t\n": - k += 1 - if k >= len(after) or after[k] not in ";{=": + # consume qualifiers + mq = QUALIFIER_RE.match(stripped, pos) + if mq: + pos = mq.end() + while pos < n and stripped[pos] in " \t\n": + pos += 1 + continue + # consume trailing return type: `-> ReturnType` + if ( + pos + 1 < n + and stripped[pos] == "-" + and stripped[pos + 1] == ">" + ): + pos = _skip_trailing_return_type(stripped, pos) + while pos < n and stripped[pos] in " \t\n": + pos += 1 + continue + # consume constructor member initializer list: `: members...` + # but avoid scope-resolution `::` — the prior non-whitespace + # char must be `)` (the closing param paren we just matched) + if pos < n and stripped[pos] == ":": + pre_colon = pos - 1 + while pre_colon >= 0 and stripped[pre_colon] in " \t\n": + pre_colon -= 1 + if pre_colon == j: + pos = _skip_member_initializer_list(stripped, pos) + while pos < n and stripped[pos] in " \t\n": + pos += 1 + continue + break + if pos >= n or stripped[pos] not in ";{=": i = j + 1 continue # for `;` and `=`, require a return-type prefix (else it looks like a # function call). For `{`, allow empty prefix (constructor/destructor). - if after[k] in ";=" and not prefix_stripped: + if stripped[pos] in ";=" and not prefix_stripped: i = j + 1 continue @@ -859,17 +982,43 @@ def find_function_bodies(content: str) -> List[Tuple[int, str, int, int]]: i = m.end() continue - # find what comes after `)`: skip whitespace and qualifiers + # find what comes after `)`: skip whitespace, qualifiers, optional + # trailing-return type (`-> ReturnType`), and optional constructor + # member initializer list (`: a(x), b{y}`). pos = j + 1 while pos < n and stripped[pos] in " \t\n": pos += 1 while True: + # consume qualifiers mq = QUALIFIER_RE.match(stripped, pos) - if not mq: - break - pos = mq.end() - while pos < n and stripped[pos] in " \t\n": - pos += 1 + if mq: + pos = mq.end() + while pos < n and stripped[pos] in " \t\n": + pos += 1 + continue + # consume trailing return type: `-> ReturnType` + if ( + pos + 1 < n + and stripped[pos] == "-" + and stripped[pos + 1] == ">" + ): + pos = _skip_trailing_return_type(stripped, pos) + while pos < n and stripped[pos] in " \t\n": + pos += 1 + continue + # consume constructor member initializer list: `: members...` + # but avoid scope-resolution `::` — the prior non-whitespace + # char must be `)` (the closing param paren we just matched) + if pos < n and stripped[pos] == ":": + pre_colon = pos - 1 + while pre_colon >= 0 and stripped[pre_colon] in " \t\n": + pre_colon -= 1 + if pre_colon == j: + pos = _skip_member_initializer_list(stripped, pos) + while pos < n and stripped[pos] in " \t\n": + pos += 1 + continue + break # we need a `{` body (not `;` declaration, not `= 0` pure virtual) if pos >= n or stripped[pos] != "{": From 8df130681cb894d59f90ff2226f1a79db64150e4 Mon Sep 17 00:00:00 2001 From: abacus_fixer Date: Tue, 25 Aug 2026 07:45:03 +0800 Subject: [PATCH 20/27] fix(code_quality): blank string literals before cyclomatic complexity scan find_high_complexity_functions previously applied CYCLO_KEYWORDS_RE on top of strip_comments() output only: control-flow words inside string and character literals (e.g. 'const char* msg = "if not ok";') were counted as genuine if/for/while/switch/case/&&/|| tokens. Pipe strip_comments() through strip_strings() before slicing each function body. Since both helpers are position-preserving (replace content with spaces instead of shortening), the absolute offsets returned by find_function_bodies remain valid for the blanked text. Update docstring to document the string/char-literal blanking and the rationale (user-facing messages often mention control-flow keywords and should not inflate the complexity score). Reproducer fixed: const char* text = "if if if (x11)"; Previously reported as complexity 11; now correctly 0. --- tools/03_code_analysis/code_quality_score.py | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/tools/03_code_analysis/code_quality_score.py b/tools/03_code_analysis/code_quality_score.py index d17dd5dff28..c5b477f4ead 100644 --- a/tools/03_code_analysis/code_quality_score.py +++ b/tools/03_code_analysis/code_quality_score.py @@ -1056,8 +1056,13 @@ def find_high_complexity_functions( Cyclomatic complexity counts: if, for, while, switch, case, &&, ||. Returns list of (line_no, function_name, complexity). + + String and character literals are blanked before the regex runs so + that control-flow words appearing inside messages (e.g. + `const char* msg = "if not ok return";`) are not counted as real + control flow statements. """ - stripped = strip_comments(content) + stripped = strip_strings(strip_comments(content)) findings: List[Tuple[int, str, int]] = [] for sig_line, name, body_open, body_close in find_function_bodies(content): body = stripped[body_open + 1:body_close] From ecc3777765f7f3ecdee360d5fc8f66b54e870aae Mon Sep 17 00:00:00 2001 From: abacus_fixer Date: Tue, 25 Aug 2026 07:49:55 +0800 Subject: [PATCH 21/27] fix(code_quality): distinguish C++14 digit separators from char literals Both strip_comments() and strip_strings() previously switched into character-literal mode on every occurrence of the single-quote character, which caused the two inner quotes in to be interpreted as the start of and character literals respectively. The number was subsequently either kept verbatim (comment-strip) or blanked out (string-strip), so the advertised digit-separator C++14 detector regex never matched it at all. Add a small _is_digit_separator(content, quote_pos) helper that returns True when the characters immediately before and after a both belong to the set of characters that may appear inside a numeric literal (digits, hex letters a-f/A-F, base/type suffix letters uUlLbBxXoO, and floating-point '.'). A that satisfies this check is passed through without toggling the in_char state in either scanner. Apply the check in both strip_comments() and strip_strings() before the in_char = True transition, and update both docstrings to mention the digit-separator behaviour. Character literals such as 'x', '\'' and '\n' continue to be handled correctly because their surrounding chars are not numeric-adjacent in the required sense. Reproducer fixed: int value = 1'000'000; find_post_cpp11_features used to return no matches; now reports the digit-separator finding on line 1. --- tools/03_code_analysis/code_quality_score.py | 39 ++++++++++++++++++++ 1 file changed, 39 insertions(+) diff --git a/tools/03_code_analysis/code_quality_score.py b/tools/03_code_analysis/code_quality_score.py index c5b477f4ead..edfc010f81e 100644 --- a/tools/03_code_analysis/code_quality_score.py +++ b/tools/03_code_analysis/code_quality_score.py @@ -376,11 +376,37 @@ def discover_files(paths: Sequence[str]) -> List[Path]: return result +def _is_digit_separator(content: str, quote_pos: int) -> bool: + """Return True if the single-quote at `quote_pos` is a C++14 digit + separator (e.g. the middle `'` in `1'000'000`). + + Heuristic: a digit separator must be preceded and followed by a + character that can belong to a numeric literal — digits, + hexadecimal letters (a–f, A–F) for hex literals, or the base/type + suffix letters (uUlLbB) that typically attach to numbers after the + body. Floating-point '.' can also appear on either side (e.g. + `1'000.5` or `1.000'5`). Any other previous/next char means the + quote starts a character literal. + """ + n = len(content) + if quote_pos <= 0 or quote_pos >= n - 1: + return False + prev = content[quote_pos - 1] + nxt = content[quote_pos + 1] + numeric_chars = set("0123456789abcdefABCDEFuUlLbBxXoO.") + return prev in numeric_chars and nxt in numeric_chars + + def strip_comments(content: str) -> str: """Return content with comments replaced by spaces, preserving line numbers. Handles // line comments and /* */ block comments. String literals are respected so that '/' inside strings is not mistaken for a comment. + + C++14 digit separators such as `1'000'000` are NOT treated as character + literals: the parser inspects the characters on both sides of a `'` and + only enters character-literal mode when the quote is genuinely opening + a char literal like `'x'` or `'\\n'`. """ out = [] i = 0 @@ -415,6 +441,10 @@ def strip_comments(content: str) -> str: i += 1 continue if c == "'": + if _is_digit_separator(content, i): + out.append(c) + i += 1 + continue in_char = True out.append(c) i += 1 @@ -452,6 +482,11 @@ def strip_strings(content: str) -> str: The result still has the same number of characters and lines, but no letter/word survives inside "..." or '...'. This prevents false matches on keywords that happen to appear inside string literals. + + C++14 digit separators such as `1'000'000` are left alone: the parser + inspects the characters on both sides of a `'` and only enters + character-literal mode when the quote genuinely opens a char literal + like `'x'` or `'\\n'`. """ out = [] i = 0 @@ -507,6 +542,10 @@ def strip_strings(content: str) -> str: i += 1 continue if c == "'": + if _is_digit_separator(content, i): + out.append(c) + i += 1 + continue in_char = True out.append("'") i += 1 From 2d87d80e0e48dcc33ada1d5b92c4eaf71d05da17 Mon Sep 17 00:00:00 2001 From: abacus_fixer Date: Tue, 25 Aug 2026 08:04:51 +0800 Subject: [PATCH 22/27] fix(code_quality): distinguish declarations from call sites in param-count scan MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit find_long_function_signatures previously accepted any candidate with a non-empty prefix text before name(...) whenever the terminator was ';' or '='. That produced duplicate reports for call sites such as: int f(int a, int b, int c, int d, int e, int f, int g, int h); int g() { return f(1, 2, 3, 4, 5, 6, 7, 8); } because the call's prefix ('return') is non-empty even though the candidate is a call expression. The same false positives hit calls inside if() conditions, argument lists, assignment RHS, throw expressions, casts, sizeof(...), coroutine keywords, etc. Introduce a dedicated _is_declaration_prefix(prefix_stripped) helper that rejects a ';' or '=' candidate when: - the prefix is empty; - the last two chars form an expression-only operator ('&&', '||', '**', '*&', '&*', '->') — single '*' and single '&' are still accepted because they are valid pointer/reference qualifiers on the return type; - the last char belongs to an expression/argument-list punctuation set ('=', '+', '-', '/', '%', '|', '^', '~', '!', '<', '>', '?', '(', '[', '{', ',', '.', ';', ':'); note '*' and '&' are NOT in this set for the reason above; - the trailing identifier token belongs to a STATEMENT_CONTEXT_KEYWORDS set that extends NON_FUNCTION_KEYWORDS with co_await/co_return/ co_yield, typeid/noexcept/alignof/alignas/decltype, the four named casts, and the C++ alternative operator tokens. Replace the old 'not prefix_stripped' one-liner in find_long_function_signatures with a call to the helper. Constructors, destructors and function bodies that terminate with '{' are not subjected to the check and keep the existing empty-prefix acceptance. Known trade-off: return types decorated with double-pointer 'int**' are intentionally skipped because the tail '**' cannot be told apart from the expression-level multiplication operator; this is a rare shape in practice and false-positive suppression is prioritized. Reproducer fixed: declaration + 'return f(1..8);' used to report f twice; now only the declaration line is reported. Assignment/if-condition/ argument-list calls no longer generate false positives, while real declarations ('virtual int calc(..) = 0;', 'const int* factory(..);', 'ns::Class::method(..) { }') still count correctly. --- tools/03_code_analysis/code_quality_score.py | 81 +++++++++++++++++++- 1 file changed, 78 insertions(+), 3 deletions(-) diff --git a/tools/03_code_analysis/code_quality_score.py b/tools/03_code_analysis/code_quality_score.py index edfc010f81e..ba03d82852a 100644 --- a/tools/03_code_analysis/code_quality_score.py +++ b/tools/03_code_analysis/code_quality_score.py @@ -223,6 +223,75 @@ "delete", "operator", "do", "else", "goto", "continue", "break", "try", } + +# Keywords that, when they appear as the last identifier in the prefix +# before a `name(args)` candidate followed by `;` or `=`, strongly +# indicate the candidate is a function call in statement/expression +# context rather than a declaration. +STATEMENT_CONTEXT_KEYWORDS = NON_FUNCTION_KEYWORDS | { + "co_await", "co_return", "co_yield", + "typeid", "noexcept", "alignof", "alignas", "decltype", + "static_cast", "const_cast", "dynamic_cast", "reinterpret_cast", + "and", "or", "not", "xor", "bitor", "bitand", "compl", +} + +# Punctuation characters that, when they are the last non-whitespace +# char before `name(args)` followed by `;` or `=`, indicate an +# expression / argument-list context (i.e. a call, not a declaration). +# `*` and `&` are intentionally NOT in this set because they also act +# as valid pointer/reference type qualifiers in a return type. The +# double-character operator forms (`&&`, `||`, `**`, etc.) are handled +# by the two-character check inside _is_declaration_prefix. +# Examples: `foo(1, bar(x), 3)` -> prefix ends with `,` +# `if (cond && ok(x))` -> prefix ends with `&&` +# `v.push_back(fn())` -> prefix ends with `.` +DECL_PREFIX_BAD_TAIL = set("=+-/%|^~!<>?([{,.;:") + +# Last-identifier regex: extracts the trailing identifier word from a +# prefix string (strips trailing punctuation and whitespace first). +_LAST_IDENT_RE = re.compile(r"([A-Za-z_]\w*)\s*$") + + +def _is_declaration_prefix(prefix_stripped: str) -> bool: + """Return True when `prefix_stripped` (the right-stripped text between + the start of the line and the candidate `name(args)` opener) is + consistent with a function declaration/definition context rather + than a call-site expression. + + A prefix is *not* a declaration prefix when: + * it is empty; + * its last non-whitespace character is punctuation that typically + appears inside expressions / argument lists (see + DECL_PREFIX_BAD_TAIL), or it is the double-character operator + form of `&&`, `||`, `**`, `->` that commonly appears inside + expressions; + * its trailing identifier token is a statement/expression + keyword (see STATEMENT_CONTEXT_KEYWORDS) such as `return`, + `throw`, `if`, `sizeof`, `static_cast`, etc. + + Constructors/destructors that open with `{` instead of `;` or `=` + are handled separately by the caller and do not go through this + check. + """ + if not prefix_stripped: + return False + tail_char = prefix_stripped[-1] + # Two-character expression operators that include `*` or `&` (which + # are not declared in the single-char bad-tail set because they are + # also valid type qualifiers). + if len(prefix_stripped) >= 2: + prev_char = prefix_stripped[-2] + double = prev_char + tail_char + if double in {"&&", "||", "**", "*&", "&*", "->"}: + return False + if tail_char in DECL_PREFIX_BAD_TAIL: + return False + m = _LAST_IDENT_RE.search(prefix_stripped) + if m and m.group(1) in STATEMENT_CONTEXT_KEYWORDS: + return False + return True + + FUNC_NAME_RE = re.compile(r"\b([A-Za-z_]\w*)\s*\(") QUALIFIER_RE = re.compile(r"\b(?:const|override|final|noexcept)\b") CYCLO_KEYWORDS_RE = re.compile(r"\b(?:if|for|while|switch|case)\b|&&|\|\|") @@ -947,9 +1016,15 @@ def find_long_function_signatures( i = j + 1 continue - # for `;` and `=`, require a return-type prefix (else it looks like a - # function call). For `{`, allow empty prefix (constructor/destructor). - if stripped[pos] in ";=" and not prefix_stripped: + # For `;` and `=`, the preceding prefix must look like a genuine + # declaration context (return type + optional specifiers) rather + # than the tail of an expression / argument list. + # - `int f(int);` prefix `int` -> declaration ✓ + # - `return f(1, 2, 3, ...);` prefix `return` -> call ✗ + # - `foo(1, bar(x), 3);` prefix `foo(1, ` -> call ✗ (ends with `,(`) + # - Constructor/destructor bodies terminate with `{` and bypass + # this check entirely. + if stripped[pos] in ";=" and not _is_declaration_prefix(prefix_stripped): i = j + 1 continue From ecc258cf04dd6e0fe1c7bbe589fffb888f841bc7 Mon Sep 17 00:00:00 2001 From: abacus_fixer Date: Tue, 25 Aug 2026 08:14:58 +0800 Subject: [PATCH 23/27] fix(code_quality): cancel smart-pointer owned new in unpaired_new heuristic The file-level leak heuristic used a straight `new_count - delete_count` difference, which could not see ownership transfers that never produce a literal `delete` keyword. The C++11 idiom that replaces std::make_unique (which only arrived in C++14) therefore looked like a leak: std::unique_ptr value; value.reset(new Foo()); // new_count=1, delete_count=0 before fix Introduce OWNED_NEW_RE, a single alternation regex covering the common smart-pointer ownership patterns: * p.reset(new T(...)) and p->reset(new T(...)) (plus operator= forms) * unique_ptr/shared_ptr/scoped_ptr/auto_ptr local variables constructed directly with (new T(...)) next to the declarator * a loose fallback for make_unique/make_shared/allocate_shapes that somehow end up wrapping a visible `new T` inside their call Inside analyze_file, compute owned_new_count with OWNED_NEW_RE, then calculate cancelled_new = delete_count + owned_new_count before deriving unpaired_new. raw_new_count deliberately stays equal to new_count and ignores the ownership cancellation: raw_new_keyword is the stylistic penalty for writing `new` instead of using make_unique/make_shared factories, so reset(new Foo) and unique_ptr(new T) correctly still contribute to that count. Document both sides of the rule split in a longer inline comment so future readers can understand why unpaired_new and raw_new_count may diverge on modern C++ files. Side note discovered during verification, NOT addressed in this patch: the existing DELETE_EXPR_RE regex always requires a `[` token after the keyword, which means plain scalar `delete p;` expressions are never counted today. This pre-existing bug is outside the scope of the current comment and is tracked separately. Reproducer fixed: value.reset(new Foo()); previously raised unpaired_new to 1; now the new is cancelled by OWNED_NEW_RE and unpaired_new stays at 0. The corresponding raw_new_keyword deduction of 1 remains intact because the code still bypasses std::make_unique / std::make_shared. --- tools/03_code_analysis/code_quality_score.py | 48 +++++++++++++++++++- 1 file changed, 46 insertions(+), 2 deletions(-) diff --git a/tools/03_code_analysis/code_quality_score.py b/tools/03_code_analysis/code_quality_score.py index ba03d82852a..2d23d7e95c4 100644 --- a/tools/03_code_analysis/code_quality_score.py +++ b/tools/03_code_analysis/code_quality_score.py @@ -193,6 +193,33 @@ FRIEND_RE = re.compile(r"\bfriend\b(?!\s+(?:class\s+|struct\s+)?std::)") NEW_EXPR_RE = re.compile(r"\bnew\s+\w") DELETE_EXPR_RE = re.compile(r"\bdelete\s*\[\s*\]?\s+\w") + +# Occurrences of `new T(...)` or `new T[...]` that are clearly owned by a +# smart-pointer wrapper and therefore should NOT count as unpaired +# new/delete leaks. Two idiomatic C++11 shapes are recognised: +# 1. `ptr.reset(new T(args))` / `ptr->reset(new T(args))` +# — reset() transfers ownership into an existing smart pointer; +# most commonly used with unique_ptr/shared_ptr when make_unique/ +# make_shared are not available (pre-C++14) or unsuitable. +# 2. `unique_ptr p(new T(args))` / `shared_ptr p(new T(args))` +# plus the allocator-taking `allocate_shared` form — direct +# construction of a smart pointer that owns the freshly-allocated +# object from day one. +# The pattern does NOT try to skip new in `raw_new_count` (that rule +# penalises *any* direct use of `new` vs. make_unique/make_shared); it +# only affects the ownership heuristic `unpaired_new`. +_OWNED_NEW_SHAPES = [ + # shape 1: .reset(new T or ->reset(new T (optionally with whitespace) + r"\.(?:reset|operator\s*=)\s*\(\s*new\s+\w", + r"->(?:reset|operator\s*=)\s*\(\s*new\s+\w", + # shape 2: unique_ptr ident ( new T + # shared_ptr ident ( new T + # allocate_shared ( alloc , new T -> not exact, but + # the simpler `allocate_shared<...> ( ... new T` heuristic + r"\b(?:unique_ptr|shared_ptr|scoped_ptr|auto_ptr)\s*<[^>]*>\s*[A-Za-z_]\w*\s*\(\s*new\s+\w", + r"\b(?:make_unique|make_shared|allocate_shared)\s*<[^>]*>\s*\([^;()]*?\bnew\s+\w", +] +OWNED_NEW_RE = re.compile("|".join(f"(?:{p})" for p in _OWNED_NEW_SHAPES)) GOTO_RE = re.compile(r"\bgoto\b") DEFAULT_PARAM_RE = re.compile( @@ -1417,10 +1444,27 @@ def analyze_file(path: Path) -> FileReport: # `[^();]*` in the regex already matches newlines. default_param_count = len(DEFAULT_PARAM_RE.findall(stripped_content)) - # unpaired new/delete (file-level): rough heuristic, cap applied below + # unpaired new/delete (file-level): rough heuristic, cap applied below. + # All `new` expressions are counted first. `delete` expressions are the + # obvious symmetric ownership cancel, but there is a second class of + # cancellations that never produces a `delete` keyword at all: a + # C++11 (or later) smart pointer that owns the object from construction. + # Recognised ownership-transfer patterns are aggregated in OWNED_NEW_RE + # and subtracted before comparing with `delete` so the leak heuristic + # stays meaningful on modern code that prefers std::unique_ptr / + # std::shared_ptr to manual delete. Examples that now cancel: + # ptr.reset(new Foo()); + # std::unique_ptr p(new Foo(arg)); + # These cancellations deliberately do NOT touch `raw_new_count` below + # because the "raw_new_keyword" rule charges per direct `new` regardless + # of ownership — it is the stylistic counterpart to std::make_unique / + # std::make_shared, so `reset(new Foo)` and `unique_ptr(new T)` + # must still contribute to that count. new_count = len(NEW_EXPR_RE.findall(stripped_content)) delete_count = len(DELETE_EXPR_RE.findall(stripped_content)) - unpaired_new = max(0, new_count - delete_count) + owned_new_count = len(OWNED_NEW_RE.findall(stripped_content)) + cancelled_new = delete_count + owned_new_count + unpaired_new = max(0, new_count - cancelled_new) # raw `new` keyword usage: each occurrence costs 1 (no cap) raw_new_count = new_count From d1fd9fb8d7a6a270ac3c64cc3a2e1757453effc5 Mon Sep 17 00:00:00 2001 From: abacus_fixer Date: Tue, 25 Aug 2026 09:10:24 +0800 Subject: [PATCH 24/27] fix(code_quality): skip multi-line using/typedef continuations in member scan is_public_member_var and is_static_member_var are single-line heuristics. When a using/typedef/template declaration spans multiple lines, the continuation half (e.g. ' = std::vector;') looks exactly like a member variable declaration in isolation: it ends with ';', has no parens or braces, doesn't start with a bad prefix, and contains identifier characters. This produced bogus public member findings inside structs like struct A { using value_type = std::vector; }; and inside real headers such as sto_tool.h. Add _mark_continued_decl_lines(class_lines): a per-class-body scan that returns the set of 0-based line indices belonging to a multi-line declaration started by a previous line. The scanner tracks a stack of (depth_at_starter, starter_idx) pairs for any class-body line whose stripped form begins with one of _MULTILINE_DECL_STARTERS (using, typedef, template, typename, namespace, extern, friend) and does NOT contain ';'. Subsequent lines are marked as continuations until a ';' at the starter's brace-depth closes the declaration. The starter line itself is never marked; the terminating ';' line IS marked so the per-line heuristics never see it standalone. Wire the marked set into analyze_class_blocks: * pass 0 computes continued_idxs once per class body. * pass 1 (member_var_names collection) skips continued lines so bogus names like '=' or 'std::vector' do not pollute the member/local conflict set. * pass 2 public-member rule skips continued lines before calling is_public_member_var. * pass 2 static-member rule skips continued lines before calling is_static_member_var. The starter keyword list intentionally uses bare forms (no trailing space) so that authors who wrap right after the keyword (e.g. 'typedef\n int myint;') are still detected. Reproducer fixed: using value_type = std::vector; used to report 'public member in struct A: = std::vector;'; now the continuation is suppressed and no false positive is raised. Real members declared on their own line ('int counter;', 'IntVec data;') and static members are still detected. Note (not addressed here): classes whose entire body is squashed onto the header line (e.g. 'struct B { int x; };') were already skipped by the depth-1 walk before this change; that pre-existing behaviour is unchanged. --- tools/03_code_analysis/code_quality_score.py | 114 ++++++++++++++++++- 1 file changed, 108 insertions(+), 6 deletions(-) diff --git a/tools/03_code_analysis/code_quality_score.py b/tools/03_code_analysis/code_quality_score.py index 2d23d7e95c4..47e3d83721c 100644 --- a/tools/03_code_analysis/code_quality_score.py +++ b/tools/03_code_analysis/code_quality_score.py @@ -816,6 +816,92 @@ def _match_var_decl(stripped_line: str) -> Optional[str]: return m.group(1) if m else None +# Keywords that, when they appear on a class-body line that does not yet +# end with ';', mark the start of a declaration that *may* span several +# source lines. Following lines (up to the terminating ';') should not be +# mistaken for individual member-variable declarations. This catches +# multi-line `using`/`typedef`/`template`/namespace-qualified type aliases +# such as: +# using value_type +# = std::vector; +# Without the lookahead, the second line is inspected in isolation and +# reads as `= std::vector;` — a bogus public-static member hit. +_MULTILINE_DECL_STARTERS = ( + # Both the space-separated form (`using value_type = ...`) and the + # bare-keyword-alone form (`typedef` at the end of a line with a + # line-break before the type) are valid. Using tuples of both + # spellings catches multi-line aliases regardless of where the + # author wraps the line. + "using", "typedef", "template", "typename", + "namespace", "extern", "friend", +) + + +def _mark_continued_decl_lines(class_lines: List[str]) -> "set": + """Return the set of 0-based line indices inside a class body that + belong to a multi-line declaration started by a previous line (and + therefore must not be treated as standalone member declarations). + + A line is considered a "continuation line" when: + * there exists a strictly earlier non-empty line at the same or + smaller brace-nesting depth that begins with a declaration + starter keyword (`using`, `typedef`, `template`, `typename`, + `namespace`, `extern`, `friend`); + * the earlier starter line does NOT terminate with ';' (i.e. the + declaration has not been closed yet); + * no ';' has been seen on any intervening line at the starter's + brace-nesting depth since the starter was opened. + + The heuristic is deliberately conservative: lines are only marked as + continuations inside the same brace-depth run so that real member + declarations following a `using` block are never incorrectly + suppressed. + """ + marked: set = set() + depth = 0 + # stack of (depth_at_starter, starter_line_idx) for currently-open + # multi-line declaration starters. Multiple starters may coexist at + # different brace-nesting levels; a semicolon at depth D closes all + # starters that were opened at exactly D (conservative, but this + # matches how class bodies declare one item per terminating ';'). + open_starters: List[Tuple[int, int]] = [] + for idx, line in enumerate(class_lines): + prev_depth = depth + stripped_l = line.strip() + # (1) Mark as continuation BEFORE processing any ';' on this line: + # the terminating-semicolon line is still part of the multi-line + # declaration and must be suppressed in the public/static-member + # heuristics. The starter line itself is never marked; every + # later line that runs while any starter is open is marked. + if open_starters and any(idx > sidx for _, sidx in open_starters): + marked.add(idx) + # (2) Now close starters at prev_depth if the current line + # contains a ';' at that depth. Closure happens AFTER the + # marking step so the line that carries the terminating ';' is + # still counted as the final continuation of the declaration. + if stripped_l and ";" in stripped_l: + closed_depths = {d for d, _ in open_starters if d == prev_depth} + if closed_depths: + open_starters = [ + (d, sidx) for (d, sidx) in open_starters + if d not in closed_depths + ] + # (3) Advance brace-depth for the current line (in/out of + # functions, nested classes, etc.). Starter-opening happens + # after depth tracking so the starter is recorded at its + # prev_depth, which is the same depth at which the terminating + # ';' will be processed. + depth += line.count("{") - line.count("}") + # (4) Lines that begin with declaration-starter keywords but do + # NOT contain ';' will (in a well-formed class body) continue + # across at least one more line before reaching the terminating + # ';'. Record them so subsequent lines can be marked. + if prev_depth >= 1 and stripped_l and ";" not in stripped_l \ + and stripped_l.startswith(_MULTILINE_DECL_STARTERS): + open_starters.append((prev_depth, idx)) + return marked + + def _skip_trailing_return_type(s: str, start: int) -> int: """Advance past `-> ReturnType` starting at position `start`. @@ -1269,16 +1355,24 @@ def analyze_class_blocks( cur_access = m.group(1) access_per_line.append(cur_access) + # pass 0: identify lines belonging to multi-line declarations that + # start with keywords such as `using`, `typedef`, `template`, etc. + # Continuation lines (e.g. the "= std::vector;" half of a + # two-line `using value_type = ...;` alias) would otherwise be + # treated as standalone member declarations when the per-line + # heuristics run below. + continued_idxs = _mark_continued_decl_lines(class_lines) + # pass 1: collect all member variable names (any access section). # depth starts at 0; the class header line brings it to 1. Only lines # that begin AND end at depth 1 are class-body member declarations # (lines that open a function body bring depth from 1 to 2). member_var_names: set = set() depth = 0 - for line in class_lines: + for idx, line in enumerate(class_lines): prev_depth = depth depth += line.count("{") - line.count("}") - if prev_depth == 1 and depth == 1: + if prev_depth == 1 and depth == 1 and idx not in continued_idxs: var_name = _match_var_decl(line) if var_name: member_var_names.add(var_name) @@ -1291,8 +1385,13 @@ def analyze_class_blocks( abs_line = body_start + idx + 1 # 1-indexed absolute line prev_depth = depth - # public member variable: only at depth 1 (class body, not in a function) - if prev_depth == 1 and access_per_line[idx] == "public": + # public member variable: only at depth 1 (class body, not in a + # function). Lines flagged as continuations of an earlier + # multi-line declaration are skipped regardless of how they + # look in isolation — e.g. ` = std::vector;` after a + # two-line `using value_type` alias must not count as a member. + if prev_depth == 1 and access_per_line[idx] == "public" \ + and idx not in continued_idxs: if is_public_member_var(line): pub_findings.append(Finding( rule="public_member_variable", @@ -1303,8 +1402,11 @@ def analyze_class_blocks( # static member variable: depth 1, any access section. # Excludes static_assert, static member functions, and - # static_cast via is_static_member_var's heuristic. - if prev_depth == 1 and is_static_member_var(line): + # static_cast via is_static_member_var's heuristic. Continued + # multi-line declarations are skipped for the same reason + # documented above for the public-member rule. + if prev_depth == 1 and idx not in continued_idxs \ + and is_static_member_var(line): static_findings.append(Finding( rule="static_member_variable", line=abs_line, From 7f237b240345e0af54db1fc9c2d4aad7168e1fd8 Mon Sep 17 00:00:00 2001 From: abacus_fixer Date: Tue, 25 Aug 2026 09:22:42 +0800 Subject: [PATCH 25/27] fix(code_quality): exclude arrow member access from uppercase constant rule UPPERCASE_CONST_RE used a (?' (arrow) form of member access was missing: 'ptr->UPPER_MEMBER' still matched UPPER_MEMBER even though the semantically equivalent 'obj.MEMBER' and 'Type::MEMBER' were already excluded. This produced different scores for equivalent code depending on whether a pointer or a value/member-access was used. Add '>' to the lookbehind character class so that the character immediately preceding the identifier is now '.' | ':' | '>'. '>' is a literal inside a Python regex character class and requires no escaping. The lookahead (?![.:]) is intentionally left unchanged: the token that follows an arrow member access is usually ';', '(', '=', or whitespace, never '.' or ':', so mirroring the '>' there would be dead weight. This keeps the rule symmetric with how '.' and ':' were already handled (prefix-only exclusion). Reproducer fixed: value = ptr->UPPER_MEMBER; used to match UPPER_MEMBER (1 deduction); now excluded, matching the existing behaviour for obj.MEMBER and Type::MEMBER. Real constants declared on their own line (MY_CONSTANT, GLOBAL_MAX, RED/GREEN/BLUE enum values, #define FOO macros, function-argument constants such as func(MAX_VAL)) are still detected. --- tools/03_code_analysis/code_quality_score.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tools/03_code_analysis/code_quality_score.py b/tools/03_code_analysis/code_quality_score.py index 47e3d83721c..9810d4a3dc0 100644 --- a/tools/03_code_analysis/code_quality_score.py +++ b/tools/03_code_analysis/code_quality_score.py @@ -184,7 +184,7 @@ CHINESE_RE = re.compile("[\u4e00-\u9fff]") USING_NS_STD_RE = re.compile(r"\busing\s+namespace\s+std\b") -UPPERCASE_CONST_RE = re.compile(r"(?])\b[A-Z][A-Z0-9_]{2,}\b(?![.:])") ACCESS_RE = re.compile(r"^\s*(public|private|protected)\s*:") CLASS_OPEN_RE = re.compile(r"\b(class|struct)\s+(\w+)\b") From e1394a6e614d473e36443e55fb378903061b3dc1 Mon Sep 17 00:00:00 2001 From: abacus_fixer Date: Tue, 25 Aug 2026 09:24:33 +0800 Subject: [PATCH 26/27] fix(code_quality): do not deduct for public members in struct bodies MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The public_member_variable rule previously applied uniformly to both class and struct bodies, treating any public data member as a code-quality finding regardless of the enclosing type. In C++ a struct has public access by default and public data members are the idiomatic shape for POD aggregates, value types, configuration data, and mixin tags; penalising them charges the author for writing legitimate, intended C++. Gate the finding in analyze_class_blocks on kind == 'class'. struct bodies — including struct members that appear inside an explicit 'public:' access block — no longer produce public_member_variable findings. class bodies keep the existing behaviour: public data members in a class continue to be deducted because the author of a class is expected to encapsulate state. Update the inline comment to explain the rationale so future readers understand why struct and class are treated differently. Reproducer: struct A { int counter; double value; }; used to report 2 findings (counter, value); now 0. class B { public: int counter; double value; }; still reports 2 findings. --- tools/03_code_analysis/code_quality_score.py | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/tools/03_code_analysis/code_quality_score.py b/tools/03_code_analysis/code_quality_score.py index 9810d4a3dc0..856b622c489 100644 --- a/tools/03_code_analysis/code_quality_score.py +++ b/tools/03_code_analysis/code_quality_score.py @@ -1390,7 +1390,13 @@ def analyze_class_blocks( # multi-line declaration are skipped regardless of how they # look in isolation — e.g. ` = std::vector;` after a # two-line `using value_type` alias must not count as a member. + # Only `class` bodies are penalised: in C++ a `struct` has + # public access by default and public data members are a + # legitimate, intended usage (POD aggregate, value types, + # mixin tags). Treating them as a code-quality issue would + # penalise perfectly idiomatic C++. if prev_depth == 1 and access_per_line[idx] == "public" \ + and kind == "class" \ and idx not in continued_idxs: if is_public_member_var(line): pub_findings.append(Finding( From 437e013884e1f9c202382c12bf5575f7f99e4e68 Mon Sep 17 00:00:00 2001 From: abacus_fixer Date: Tue, 25 Aug 2026 09:32:35 +0800 Subject: [PATCH 27/27] refactor(hsolver_test): replace unique_ptr heap alloc with stack vars in bpcg test MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The alpha/beta scaling constants passed to ModuleBase::gemm_op inside hpsi_func were heap-allocated via std::unique_ptr(new T(...)) and then re-exposed through .get(). GEMM only reads these values (const T* alpha / const T* beta in gemm_op::operator()), so heap allocation is unnecessary — the lambda performs a fresh new/delete pair on every call for no semantic benefit. Replace with stack-local const T one(1.0) / const T zero(0.0) and pass &one / &zero directly. The result is fully C++11-compatible (indeed C++98-compatible), shorter, and removes the only std::unique_ptr use in the file, so is no longer needed even indirectly through this translation unit's own code. Verified by building the MODULE_HSOLVER_bpcg test target: make -j 30 MODULE_HSOLVER_bpcg -> [100%] Built target MODULE_HSOLVER_bpcg --- source/source_hsolver/test/diago_bpcg_test.cpp | 10 ++++------ 1 file changed, 4 insertions(+), 6 deletions(-) diff --git a/source/source_hsolver/test/diago_bpcg_test.cpp b/source/source_hsolver/test/diago_bpcg_test.cpp index ee0b8f4aab2..37529ec60e7 100644 --- a/source/source_hsolver/test/diago_bpcg_test.cpp +++ b/source/source_hsolver/test/diago_bpcg_test.cpp @@ -136,20 +136,18 @@ class DiagoBPCGPrepare const std::vector &h_mat = DIAGOTEST::hmatrix_local; auto hpsi_func = [h_mat, dim](T *psi_in, T *hpsi_out, const int ld_psi, const int nvec) { - std::unique_ptr one(new T(1.0)); - std::unique_ptr zero(new T(0.0)); - const T *one_ = one.get(); - const T *zero_ = zero.get(); + const T one(1.0); + const T zero(0.0); base_device::DEVICE_CPU *ctx = {}; // hpsi_out(dim * nvec) = h_mat(dim * dim) * psi_in(dim * nvec) ModuleBase::gemm_op()( 'N', 'N', dim, nvec, dim, - one_, + &one, h_mat.data(), dim, psi_in, ld_psi, - zero_, + &zero, hpsi_out, ld_psi); }; const int ndim = psi_local.get_current_ngk();