cppgolf 0.1.0__tar.gz → 0.1.1__tar.gz

{cppgolf-0.1.0 → cppgolf-0.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cppgolf
-Version: 0.1.0
+Version: 0.1.1
 Summary: C++ multi-file merge & code golf / minifier tool
 License: MIT
 Project-URL: Homepage, https://github.com/yourname/cppgolf

{cppgolf-0.1.0 → cppgolf-0.1.1}/cppgolf/__main__.py

@@ -96,8 +96,8 @@ def build_parser() -> argparse.ArgumentParser:
                     help='单语句 if/for/while 去花括号')
     g2.add_argument('--shortcuts', dest='define_shortcuts', action='store_true',
                     help='高频 cout/cin 用 #define 缩写')
-    g2.add_argument('--rename', dest='rename_symbols', action='store_true',
-                    help='将用户变量/成员名压缩为短名（需要 tree-sitter-cpp）')
+    g2.add_argument('-no-rename', dest='no_rename_symbols', action='store_true',
+                    help='不将用户变量/成员名压缩为短名（需要 tree-sitter-cpp）')
 
     p.add_argument('--stats', action='store_true', help='显示压缩率统计')
     return p
@@ -124,7 +124,7 @@ def main():
         keep_inline=args.keep_inline,
         aggressive=args.aggressive,
         define_shortcuts=args.define_shortcuts,
-        rename_symbols=args.rename_symbols,
+        rename_symbols=not(args.no_rename_symbols),
     )
 
     def print_stats(final_size: int):

{cppgolf-0.1.0 → cppgolf-0.1.1}/cppgolf/golf_rename.py

@@ -2,9 +2,11 @@
 golf_rename.py — Pass 5: 符号名压缩（tree-sitter AST 驱动）
 """
 import re
-import sys
 import itertools
 
+from tree_sitter import Language, Parser
+import tree_sitter_cpp as tscpp
+
 _DECLARATOR_CONTAINERS = frozenset({
     'init_declarator', 'pointer_declarator', 'reference_declarator',
     'array_declarator', 'abstract_pointer_declarator',
@@ -12,6 +14,28 @@ _DECLARATOR_CONTAINERS = frozenset({
 })
 _MIN_RENAME_LEN = 2
 
+# C/C++ 保留关键字，生成短名时不得使用
+_CXX_KEYWORDS = frozenset({
+    # C keywords
+    'auto', 'break', 'case', 'char', 'const', 'continue', 'default',
+    'do', 'double', 'else', 'enum', 'extern', 'float', 'for', 'goto',
+    'if', 'inline', 'int', 'long', 'register', 'restrict', 'return',
+    'short', 'signed', 'sizeof', 'static', 'struct', 'switch', 'typedef',
+    'union', 'unsigned', 'void', 'volatile', 'while',
+    # C++ keywords
+    'alignas', 'alignof', 'and', 'and_eq', 'asm', 'bitand', 'bitor',
+    'bool', 'catch', 'class', 'compl', 'concept', 'consteval', 'constexpr',
+    'constinit', 'co_await', 'co_return', 'co_yield', 'decltype', 'delete',
+    'explicit', 'export', 'false', 'friend', 'mutable', 'namespace',
+    'new', 'noexcept', 'not', 'not_eq', 'nullptr', 'operator', 'or',
+    'or_eq', 'private', 'protected', 'public', 'requires', 'static_assert',
+    'static_cast', 'dynamic_cast', 'reinterpret_cast', 'const_cast',
+    'template', 'this', 'thread_local', 'throw', 'true', 'try', 'typeid',
+    'typename', 'using', 'virtual', 'wchar_t', 'xor', 'xor_eq',
+    # common macros / built-ins that must not be shadowed
+    'NULL', 'TRUE', 'FALSE', 'EOF', 'stdin', 'stdout', 'stderr',
+})
+
 
 def _gen_short_names():
     for length in itertools.count(1):
@@ -54,14 +78,20 @@ class _RenameCtx:
         return self.src[node.start_byte:node.end_byte].decode('utf-8')
 
     def _get_primary_type_name(self, node) -> str | None:
+        result = None
         for ch in node.children:
             if ch.type in ('type_identifier', 'primitive_type'):
-                return self.name_of(ch)
-            if ch.type == 'qualified_identifier':
+                result = self.name_of(ch)
+            elif ch.type == 'qualified_identifier':
                 for sub in reversed(ch.children):
                     if sub.type in ('identifier', 'type_identifier'):
-                        return self.name_of(sub)
-        return None
+                        result = self.name_of(sub); break
+            elif ch.type == 'ERROR':
+                # tree-sitter 遇到宏（如 F_BEGIN）时会把真正的类型包进 ERROR 节点
+                for sub in ch.children:
+                    if sub.type in ('type_identifier', 'identifier'):
+                        result = self.name_of(sub); break
+        return result
 
     def _is_qid_name(self, node) -> bool:
         par = node.parent
@@ -219,16 +249,82 @@ class _RenameCtx:
                             if vtype:
                                 return vtype
                             return self._extract_init_cast_type(child, var_name)
+                # function_definition：参数列表不在祖先链上，需主动下探
+                if node.type == 'function_definition':
+                    for child in node.children:
+                        if child.type in ('function_declarator', 'pointer_declarator',
+                                          'reference_declarator'):
+                            for sub in child.children:
+                                if sub.type == 'parameter_list':
+                                    for param in sub.children:
+                                        if param.type != 'parameter_declaration':
+                                            continue
+                                        vtype = self._get_primary_type_name(param)
+                                        if not vtype:
+                                            continue
+                                        for ch in param.children:
+                                            if ch.type == 'identifier' and self.name_of(ch) == var_name:
+                                                return vtype
+                                            elif ch.type in _DECLARATOR_CONTAINERS:
+                                                id_nd = _extract_declarator_id(ch, False)
+                                                if id_nd and self.name_of(id_nd) == var_name:
+                                                    return vtype
+            # for-range loop 变量：for (Type var : range)
+            if node.type == 'for_range_loop':
+                loop_type = self._get_primary_type_name(node)  # 直接子节点里找 type_identifier
+                found_first = False
+                for ch in node.children:
+                    if ch.type in (':', 'compound_statement'):
+                        break
+                    if ch.is_named and not found_first:
+                        found_first = True   # 跳过类型说明符节点本身
+                        continue
+                    if ch.type == 'identifier' and self.name_of(ch) == var_name:
+                        return loop_type
+                    elif ch.type in _DECLARATOR_CONTAINERS:
+                        id_nd = _extract_declarator_id(ch, False)
+                        if id_nd and self.name_of(id_nd) == var_name:
+                            return loop_type
+            # 类/结构体成员字段（方法内访问 this->field 或其他成员变量）
+            if node.type in ('struct_specifier', 'class_specifier', 'union_specifier'):
+                for ch in node.children:
+                    if ch.type == 'field_declaration_list':
+                        for fd in ch.children:
+                            if fd.type != 'field_declaration':
+                                continue
+                            vtype = self._get_primary_type_name(fd)
+                            for fc in fd.children:
+                                if fc.type == 'field_identifier' and self.name_of(fc) == var_name:
+                                    return vtype
+                                elif fc.type in _DECLARATOR_CONTAINERS or fc.type == 'init_declarator':
+                                    id_nd = _extract_declarator_id(fc, True)
+                                    if id_nd and self.name_of(id_nd) == var_name:
+                                        return vtype
+                        break
             node = node.parent
         return self.var_type_map.get(var_name)
 
     # ── 字段访问对象类型推断 ─────────────────────────────────────────────
+    def _enclosing_class(self, node) -> str | None:
+        """向上找最近的 class/struct/union 定义，返回其名字。"""
+        n = node.parent
+        while n is not None:
+            if n.type in ('struct_specifier', 'class_specifier', 'union_specifier'):
+                for ch in n.children:
+                    if ch.type == 'type_identifier':
+                        return self.name_of(ch)
+            n = n.parent
+        return None
+
     def _resolve_field_object_type(self, field_expr_node) -> str | None:
         if not field_expr_node.children:
             return None
         value_node = field_expr_node.children[0]
         vt = value_node.type
         td = self.typedef_map
+        if vt == 'this':
+            cls = self._enclosing_class(field_expr_node)
+            return td.get(cls, cls) if cls else None
         if vt == 'identifier':
             t = self._lookup_var_type_in_scope(value_node)
             return td.get(t, t)
@@ -255,198 +351,191 @@ class _RenameCtx:
             elif arr.type == 'field_expression':
                 return self._resolve_field_object_type(arr)
         return None
-
-    # ── 步骤 1：收集声明位节点 ────────────────────────────────────────────
-    def collect_decl_nodes(self):
-        local_decl: list = []
-        member_decl: list = []
-
-        def walk(node):
-            nt = node.type
-            if nt == 'declaration':
-                for ch in node.children:
-                    if ch.type == 'identifier':
-                        local_decl.append(ch)
-                    elif ch.type in _DECLARATOR_CONTAINERS or ch.type == 'init_declarator':
-                        id_node = _extract_declarator_id(ch, False)
-                        if id_node: local_decl.append(id_node)
-                    elif ch.type == 'function_declarator':
-                        decl_type = self._get_primary_type_name(node)
-                        if decl_type and decl_type in self.user_struct_names:
-                            for sub in ch.children:
-                                if sub.type == 'identifier':
-                                    local_decl.append(sub); break
-            elif nt == 'parameter_declaration':
-                for ch in node.children:
-                    if ch.type == 'identifier':
-                        local_decl.append(ch)
-                    elif ch.type in _DECLARATOR_CONTAINERS:
-                        id_node = _extract_declarator_id(ch, False)
-                        if id_node: local_decl.append(id_node)
-            elif nt == 'for_range_loop':
-                found_type = False
-                for ch in node.children:
-                    if ch.type in (':', 'compound_statement'): break
-                    if ch.is_named and not found_type:
-                        found_type = True; continue
-                    if ch.type == 'identifier':
-                        local_decl.append(ch); break
-                    elif ch.type in _DECLARATOR_CONTAINERS:
-                        id_node = _extract_declarator_id(ch, False)
-                        if id_node: local_decl.append(id_node)
-                        break
-            elif nt == 'field_declaration':
-                for ch in node.children:
-                    if ch.type == 'field_identifier':
-                        member_decl.append(ch)
-                    elif ch.type in _DECLARATOR_CONTAINERS or ch.type == 'init_declarator':
-                        id_node = _extract_declarator_id(ch, True)
-                        if id_node: member_decl.append(id_node)
-            if nt == 'function_declarator':
-                for ch in node.children:
-                    if ch.type != 'identifier': walk(ch)
-            else:
-                for ch in node.children: walk(ch)
-
-        walk(self.tree.root_node)
-        return local_decl, member_decl
-
-    # ── 步骤 3：统计频率 ──────────────────────────────────────────────────
-    def count_freq(self, local_names, member_names) -> dict:
-        freq: dict = {}
-        def walk(node):
-            if node.type == 'identifier':
-                n = self.name_of(node)
-                if n in local_names:
-                    freq[n] = freq.get(n, 0) + 1
-                elif n in member_names and self._is_qid_name(node):
-                    scope_cls = self._get_qid_scope_class(node.parent)
-                    real_cls = self.typedef_map.get(scope_cls, scope_cls) if scope_cls else None
-                    if real_cls and real_cls in self.user_struct_names:
-                        freq[n] = freq.get(n, 0) + 1
-            elif node.type == 'field_identifier':
-                n = self.name_of(node)
-                if n in member_names: freq[n] = freq.get(n, 0) + 1
-            elif node.type == 'type_identifier':
-                n = self.name_of(node)
-                if n in local_names:
-                    par = node.parent
-                    if (par and par.type == 'parameter_declaration'
-                            and par.parent and par.parent.type == 'parameter_list'
-                            and par.parent.parent and par.parent.parent.type == 'function_declarator'
-                            and par.parent.parent.parent
-                            and par.parent.parent.parent.type == 'declaration'):
-                        freq[n] = freq.get(n, 0) + 1
-            for ch in node.children: walk(ch)
-        walk(self.tree.root_node)
+
+    # ── 步骤 1：收集声明位节点 ────────────────────────────────────────────
+    def collect_decl_nodes(self):
+        local_decl: list = []
+        member_decl: list = []
+
+        def walk(node):
+            nt = node.type
+            if nt == 'declaration':
+                for ch in node.children:
+                    if ch.type == 'identifier':
+                        local_decl.append(ch)
+                    elif ch.type in _DECLARATOR_CONTAINERS or ch.type == 'init_declarator':
+                        id_node = _extract_declarator_id(ch, False)
+                        if id_node: local_decl.append(id_node)
+                    elif ch.type == 'function_declarator':
+                        decl_type = self._get_primary_type_name(node)
+                        if decl_type and decl_type in self.user_struct_names:
+                            for sub in ch.children:
+                                if sub.type == 'identifier':
+                                    local_decl.append(sub); break
+            elif nt == 'parameter_declaration':
+                for ch in node.children:
+                    if ch.type == 'identifier':
+                        local_decl.append(ch)
+                    elif ch.type in _DECLARATOR_CONTAINERS:
+                        id_node = _extract_declarator_id(ch, False)
+                        if id_node: local_decl.append(id_node)
+            elif nt == 'for_range_loop':
+                found_type = False
+                for ch in node.children:
+                    if ch.type in (':', 'compound_statement'): break
+                    if ch.is_named and not found_type:
+                        found_type = True; continue
+                    if ch.type == 'identifier':
+                        local_decl.append(ch); break
+                    elif ch.type in _DECLARATOR_CONTAINERS:
+                        id_node = _extract_declarator_id(ch, False)
+                        if id_node: local_decl.append(id_node)
+                        break
+            elif nt == 'field_declaration':
+                for ch in node.children:
+                    if ch.type == 'field_identifier':
+                        member_decl.append(ch)
+                    elif ch.type in _DECLARATOR_CONTAINERS or ch.type == 'init_declarator':
+                        id_node = _extract_declarator_id(ch, True)
+                        if id_node: member_decl.append(id_node)
+            if nt == 'function_declarator':
+                for ch in node.children:
+                    if ch.type != 'identifier': walk(ch)
+            else:
+                for ch in node.children: walk(ch)
+
+        walk(self.tree.root_node)
+        return local_decl, member_decl
+
+    # ── 步骤 3：统计频率 ──────────────────────────────────────────────────
+    def count_freq(self, local_names, member_names) -> dict:
+        freq: dict = {}
+        def walk(node):
+            if node.type == 'identifier':
+                n = self.name_of(node)
+                if n in local_names:
+                    freq[n] = freq.get(n, 0) + 1
+                elif n in member_names and self._is_qid_name(node):
+                    scope_cls = self._get_qid_scope_class(node.parent)
+                    real_cls = self.typedef_map.get(scope_cls, scope_cls) if scope_cls else None
+                    if real_cls and real_cls in self.user_struct_names:
+                        freq[n] = freq.get(n, 0) + 1
+            elif node.type == 'field_identifier':
+                n = self.name_of(node)
+                if n in member_names: freq[n] = freq.get(n, 0) + 1
+            elif node.type == 'type_identifier':
+                n = self.name_of(node)
+                if n in local_names:
+                    par = node.parent
+                    if (par and par.type == 'parameter_declaration'
+                            and par.parent and par.parent.type == 'parameter_list'
+                            and par.parent.parent and par.parent.parent.type == 'function_declarator'
+                            and par.parent.parent.parent
+                            and par.parent.parent.parent.type == 'declaration'):
+                        freq[n] = freq.get(n, 0) + 1
+            for ch in node.children: walk(ch)
+        walk(self.tree.root_node)
         return freq
-
-    # ── 步骤 5：收集替换位置 ──────────────────────────────────────────────
-    def build_replacements(self, rename_map, local_names, member_names):
-        replacements: list = []
-        class_stack: list = []
-
-        def walk(node):
-            entered = False
-            nt = node.type
-            if nt in ('struct_specifier', 'class_specifier', 'union_specifier'):
-                for ch in node.children:
-                    if ch.type == 'type_identifier':
-                        class_stack.append(self.name_of(ch)); entered = True; break
-
-            if nt == 'identifier':
-                n = self.name_of(node)
-                if n in rename_map and n in local_names:
-                    replacements.append((node.start_byte, node.end_byte, rename_map[n].encode()))
-                elif n in rename_map and n in member_names and class_stack:
-                    replacements.append((node.start_byte, node.end_byte, rename_map[n].encode()))
-                elif n in rename_map and n in member_names and self._is_qid_name(node):
-                    scope_cls = self._get_qid_scope_class(node.parent)
-                    real_cls = self.typedef_map.get(scope_cls, scope_cls) if scope_cls else None
-                    if real_cls and real_cls in self.user_struct_names:
-                        replacements.append((node.start_byte, node.end_byte, rename_map[n].encode()))
-            elif nt == 'type_identifier':
-                n = self.name_of(node)
-                if n in rename_map and n in local_names:
-                    par = node.parent
-                    if (par and par.type == 'parameter_declaration'
-                            and par.parent and par.parent.type == 'parameter_list'
-                            and par.parent.parent and par.parent.parent.type == 'function_declarator'
-                            and par.parent.parent.parent
-                            and par.parent.parent.parent.type == 'declaration'):
-                        decl_type = self._get_primary_type_name(par.parent.parent.parent)
-                        if decl_type and decl_type in self.user_struct_names:
-                            replacements.append((node.start_byte, node.end_byte, rename_map[n].encode()))
-            elif nt == 'field_identifier':
-                n = self.name_of(node)
-                if n in rename_map and n in member_names:
-                    parent = node.parent
-                    if parent and parent.type == 'field_expression':
-                        obj_type = self._resolve_field_object_type(parent)
-                        if obj_type and obj_type in self.user_struct_names:
-                            replacements.append((node.start_byte, node.end_byte, rename_map[n].encode()))
-                    else:
-                        replacements.append((node.start_byte, node.end_byte, rename_map[n].encode()))
-
-            for ch in node.children: walk(ch)
-            if entered: class_stack.pop()
-
-        walk(self.tree.root_node)
-        return replacements
-
-    # ── 步骤 6：应用替换 ──────────────────────────────────────────────────
-    def apply(self, replacements) -> str:
-        replacements.sort(key=lambda x: x[0], reverse=True)
-        buf = bytearray(self.src)
-        for start, end, new in replacements:
-            buf[start:end] = new
-        return buf.decode('utf-8')
-
-
-# ─────────────────────────────────────────────────────────────────────────────
-# 公开入口
-# ─────────────────────────────────────────────────────────────────────────────
-def golf_rename_symbols(code: str) -> str:
-    try:
-        from tree_sitter import Language, Parser
-        import tree_sitter_cpp as tscpp
-        _lang = Language(tscpp.language())
-    except ImportError:
-        print('[警告] 未找到 tree-sitter，跳过符号重命名。'
-              '  运行: pip install tree-sitter tree-sitter-cpp', file=sys.stderr)
-        return code
-
-    src_bytes = code.encode('utf-8')
-    parser = Parser(_lang)
-    tree = parser.parse(src_bytes)
-
-    ctx = _RenameCtx(src_bytes, tree)
-    ctx.build_type_context()
-
-    local_decl, member_decl = ctx.collect_decl_nodes()
-    name_of = ctx.name_of
-
-    local_names  = {name_of(n) for n in local_decl  if len(name_of(n)) >= _MIN_RENAME_LEN}
-    member_names = {name_of(n) for n in member_decl if len(name_of(n)) >= _MIN_RENAME_LEN}
-    if not local_names and not member_names:
-        return code
-
-    all_targets = local_names | member_names
-    freq = ctx.count_freq(local_names, member_names)
-
-    # 步骤 4：生成重命名映射
-    all_existing = set(re.findall(r'\b[A-Za-z_]\w*\b', code))
-    occupied = set(all_existing)
-    rename_map: dict = {}
-    gen = _gen_short_names()
-    for original in sorted(all_targets, key=lambda x: -freq.get(x, 0)):
-        short = next(gen)
-        while short in occupied or short == original:
-            short = next(gen)
-        rename_map[original] = short
-        occupied.add(short)
-
-    replacements = ctx.build_replacements(rename_map, local_names, member_names)
-    if not replacements:
-        return code
+
+    # ── 步骤 5：收集替换位置 ──────────────────────────────────────────────
+    def build_replacements(self, rename_map, local_names, member_names):
+        replacements: list = []
+        class_stack: list = []
+
+        def walk(node):
+            entered = False
+            nt = node.type
+            if nt in ('struct_specifier', 'class_specifier', 'union_specifier'):
+                for ch in node.children:
+                    if ch.type == 'type_identifier':
+                        class_stack.append(self.name_of(ch)); entered = True; break
+
+            if nt == 'identifier':
+                n = self.name_of(node)
+                if n in rename_map and n in local_names:
+                    replacements.append((node.start_byte, node.end_byte, rename_map[n].encode()))
+                elif n in rename_map and n in member_names and class_stack:
+                    replacements.append((node.start_byte, node.end_byte, rename_map[n].encode()))
+                elif n in rename_map and n in member_names and self._is_qid_name(node):
+                    scope_cls = self._get_qid_scope_class(node.parent)
+                    real_cls = self.typedef_map.get(scope_cls, scope_cls) if scope_cls else None
+                    if real_cls and real_cls in self.user_struct_names:
+                        replacements.append((node.start_byte, node.end_byte, rename_map[n].encode()))
+            elif nt == 'type_identifier':
+                n = self.name_of(node)
+                if n in rename_map and n in local_names:
+                    par = node.parent
+                    if (par and par.type == 'parameter_declaration'
+                            and par.parent and par.parent.type == 'parameter_list'
+                            and par.parent.parent and par.parent.parent.type == 'function_declarator'
+                            and par.parent.parent.parent
+                            and par.parent.parent.parent.type == 'declaration'):
+                        decl_type = self._get_primary_type_name(par.parent.parent.parent)
+                        if decl_type and decl_type in self.user_struct_names:
+                            replacements.append((node.start_byte, node.end_byte, rename_map[n].encode()))
+            elif nt == 'field_identifier':
+                n = self.name_of(node)
+                if n in rename_map and n in member_names:
+                    parent = node.parent
+                    if parent and parent.type == 'field_expression':
+                        obj_type = self._resolve_field_object_type(parent)
+                        if obj_type and obj_type in self.user_struct_names:
+                            replacements.append((node.start_byte, node.end_byte, rename_map[n].encode()))
+                    else:
+                        replacements.append((node.start_byte, node.end_byte, rename_map[n].encode()))
+
+            for ch in node.children: walk(ch)
+            if entered: class_stack.pop()
+
+        walk(self.tree.root_node)
+        return replacements
+
+    # ── 步骤 6：应用替换 ──────────────────────────────────────────────────
+    def apply(self, replacements) -> str:
+        replacements.sort(key=lambda x: x[0], reverse=True)
+        buf = bytearray(self.src)
+        for start, end, new in replacements:
+            buf[start:end] = new
+        return buf.decode('utf-8')
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# 公开入口
+# ─────────────────────────────────────────────────────────────────────────────
+def golf_rename_symbols(code: str) -> str:
+    _lang = Language(tscpp.language())
+
+    src_bytes = code.encode('utf-8')
+    parser = Parser(_lang)
+    tree = parser.parse(src_bytes)
+
+    ctx = _RenameCtx(src_bytes, tree)
+    ctx.build_type_context()
+
+    local_decl, member_decl = ctx.collect_decl_nodes()
+    name_of = ctx.name_of
+
+    local_names  = {name_of(n) for n in local_decl  if len(name_of(n)) >= _MIN_RENAME_LEN}
+    member_names = {name_of(n) for n in member_decl if len(name_of(n)) >= _MIN_RENAME_LEN}
+    if not local_names and not member_names:
+        return code
+
+    all_targets = local_names | member_names
+    freq = ctx.count_freq(local_names, member_names)
+
+    # 步骤 4：生成重命名映射
+    all_existing = set(re.findall(r'\b[A-Za-z_]\w*\b', code))
+    occupied = all_existing | _CXX_KEYWORDS
+    rename_map: dict = {}
+    gen = _gen_short_names()
+    for original in sorted(all_targets, key=lambda x: -freq.get(x, 0)):
+        short = next(gen)
+        while short in occupied or short == original:
+            short = next(gen)
+        rename_map[original] = short
+        occupied.add(short)
+
+    replacements = ctx.build_replacements(rename_map, local_names, member_names)
+    if not replacements:
+        return code
     return ctx.apply(replacements)

{cppgolf-0.1.0 → cppgolf-0.1.1}/cppgolf/transforms.py

@@ -20,29 +20,40 @@ def golf_std_namespace(code: str) -> str:
 
 
 def golf_typedefs(code: str) -> str:
-    """对高频长类型名添加 #define 缩写（出现 ≥2 次时触发）。"""
+    """对高频长类型名添加 typedef 缩写（出现 ≥2 次时触发）。"""
     replacements = [
-        (r'\blong long\b',          'll',   '#define ll long long'),
-        (r'\bunsigned long long\b', 'ull',  '#define ull unsigned long long'),
-        (r'\blong double\b',        'ld',   '#define ld long double'),
-        (r'\bvector<int>\b',        'vi',   '#define vi vector<int>'),
-        (r'\bvector<ll>\b',         'vll',  '#define vll vector<ll>'),
-        (r'\bpair<int,int>\b',      'pii',  '#define pii pair<int,int>'),
-        (r'\bpair<ll,ll>\b',        'pll',  '#define pll pair<ll,ll>'),
+        (r'\blong long\b',          'll',   'typedef long long ll;'),
+        (r'\bunsigned long long\b', 'ull',  'typedef unsigned long long ull;'),
+        (r'\blong double\b',        'ld',   'typedef long double ld;'),
+        (r'\bvector<int>\b',        'vi',   'typedef vector<int> vi;'),
+        (r'\bvector<ll>\b',         'vll',  'typedef vector<ll> vll;'),
+        (r'\bpair<int,int>\b',      'pii',  'typedef pair<int,int> pii;'),
+        (r'\bpair<ll,ll>\b',        'pll',  'typedef pair<ll,ll> pll;'),
     ]
     defines_to_add = []
     for pattern, short, defline in replacements:
-        macro = defline.split()[1]
-        if re.search(r'\b' + re.escape(macro) + r'\b', code):
-            continue
-        if len(re.findall(pattern, code)) >= 2:
+        # 提取缩写名（typedef ... short;）
+        macro = defline.rstrip(';').split()[-1]
+        # 匹配已有的 typedef 或 #define 形式
+        existing_re = re.compile(
+            r'^[ \t]*(?:'
+            r'typedef\b[^\n]+\b' + re.escape(macro) + r'\s*;'
+            r'|#[ \t]*define[ \t]+' + re.escape(macro) + r'\b[^\n]*'
+            r')[ \t]*\n?',
+            re.MULTILINE,
+        )
+        existing = existing_re.search(code)
+        if existing:
+            # 已有定义：从原位删掉，稍后统一插到顶部
+            code = code[:existing.start()] + code[existing.end():]
+            defines_to_add.append(defline)
+        elif len(re.findall(pattern, code)) >= 2:
             defines_to_add.append(defline)
             code = re.sub(pattern, short, code)
     if defines_to_add:
-        last = max(
-            (m.end() for m in re.finditer(r'^#(?:include|define)\b.*$', code, re.MULTILINE)),
-            default=0,
-        )
+        # 插入点：文件顶部 include 块末尾
+        include_ends = [m.end() for m in re.finditer(r'^[ \t]*#[ \t]*include\b.*$', code, re.MULTILINE)]
+        last = include_ends[-1] if include_ends else 0
         code = code[:last] + '\n' + '\n'.join(defines_to_add) + '\n' + code[last:]
     return code
 

{cppgolf-0.1.0 → cppgolf-0.1.1}/cppgolf.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cppgolf
-Version: 0.1.0
+Version: 0.1.1
 Summary: C++ multi-file merge & code golf / minifier tool
 License: MIT
 Project-URL: Homepage, https://github.com/yourname/cppgolf

{cppgolf-0.1.0 → cppgolf-0.1.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "cppgolf"
-version = "0.1.0"
+version = "0.1.1"
 description = "C++ multi-file merge & code golf / minifier tool"
 readme = "README.md"
 license = { text = "MIT" }