outliner-cli 0.1.0__py3-none-any.whl

outliner/parsers/clojure.py

@@ -0,0 +1,238 @@
+"""Clojure outline parser."""
+
+import re
+from collections.abc import Iterator
+
+from outliner.types import OutlineItem
+from outliner.parsers.util import seek_comment_start
+
+SYNTAX = "clojure"
+EXTENSIONS = (".clj", ".cljs", ".cljc")
+
+# Top-level forms to outline; anchored to column 0 (no leading whitespace)
+_TOP_FORM_RE = re.compile(
+    r"^\((?:defn-?|defmacro|deftype|defrecord|defprotocol|defmulti|ns|def)\s+"
+)
+
+# Forms that expect a parameter/field vector [params] as their structural element
+_PARAM_VECTOR_RE = re.compile(r"^\((?:defn-?|defmacro|deftype|defrecord)\s+")
+
+_NS_RE   = re.compile(r"^\(ns\s+[\w.-]+")
+_DEFN_RE = re.compile(r"^\(defn\s+\w")
+_DEF_RE  = re.compile(r"^\(def\s+\w")
+
+
+def detect(lines: list[str]) -> bool:
+    """Detect Clojure: (ns ...) declaration, or both defn and def at line start."""
+    if any(_NS_RE.match(l) for l in lines):
+        return True
+    return any(_DEFN_RE.match(l) for l in lines) and any(_DEF_RE.match(l) for l in lines)
+
+
+def _string_interior_lines(lines: list[str]) -> set[int]:
+    """Return 0-based indices of lines whose first character is inside a string literal.
+
+    Used to skip false-positive top-level form matches inside multi-line strings
+    (e.g. code examples in docstrings).  Clojure character literals ``\\(`` are
+    handled so they do not accidentally toggle string state.
+    """
+    in_string = False
+    result: set[int] = set()
+    for i, raw in enumerate(lines):
+        if in_string:
+            result.add(i)
+        j = 0
+        while j < len(raw):
+            ch = raw[j]
+            if in_string:
+                if ch == "\\":
+                    j += 2
+                    continue
+                if ch == '"':
+                    in_string = False
+            else:
+                if ch == "\\":
+                    j += 2  # character literal — skip the next char
+                    continue
+                if ch == '"':
+                    in_string = True
+                elif ch == ";":
+                    break  # rest is a line comment
+            j += 1
+    return result
+
+
+def _seek_paren_end(lines: list[str], start: int) -> int:
+    """Return 0-based exclusive end of the paren-balanced form starting at start.
+
+    Handles string literals and Clojure character literals (``\\(`` etc.) so
+    neither triggers spurious depth changes.
+    """
+    depth = 0
+    in_string = False
+    for i in range(start, len(lines)):
+        j = 0
+        raw = lines[i]
+        while j < len(raw):
+            ch = raw[j]
+            if in_string:
+                if ch == "\\":
+                    j += 2
+                    continue
+                if ch == '"':
+                    in_string = False
+            else:
+                if ch == "\\":
+                    j += 2  # character literal — skip next char
+                    continue
+                if ch == '"':
+                    in_string = True
+                elif ch == ";":
+                    break  # line comment
+                elif ch == "(":
+                    depth += 1
+                elif ch == ")":
+                    depth -= 1
+                    if depth <= 0:
+                        return i + 1
+            j += 1
+    return len(lines)
+
+
+def _collect_sig(lines: list[str], start: int) -> str:
+    """Collect a Clojure form signature.
+
+    For forms with a param vector (defn/defmacro/deftype/defrecord): gathers
+    text up to and including the first ``[params]`` at paren depth 1.  Stops
+    early when a sub-form opens before any vector is seen (multi-arity defn,
+    defprotocol methods, etc.).
+
+    For other forms (def, ns, defprotocol, defmulti): collects the first line
+    of the form, stopping at the form close or at a nested sub-form.
+
+    Metadata is stripped from the signature:
+    - ``^{...}`` reader-macro annotations: skipped everywhere; preceding ``^``
+      also removed.
+    - Plain ``{...}`` attribute maps before the param vector: skipped for
+      param-vector forms (defn/defmacro/deftype/defrecord).
+
+    Returns the signature string.
+    """
+    has_param_vector = bool(_PARAM_VECTOR_RE.match(lines[start]))
+
+    parts: list[str] = []
+    paren_depth = 0
+    bracket_depth = 0
+    in_string = False
+    found_bracket = False  # True once the first '[' at paren_depth==1 is seen
+    meta_depth = 0         # depth inside a skipped {..} metadata/attribute map
+
+    for i in range(start, min(start + 50, len(lines))):
+        raw = lines[i]
+        line_buf: list[str] = []
+        stop = False
+        j = 0
+
+        while j < len(raw):
+            ch = raw[j]
+
+            # --- string literal handling (highest priority) ---
+            if in_string:
+                if ch == "\\":
+                    j += 2
+                    continue
+                if ch == '"':
+                    in_string = False
+                j += 1
+                continue
+
+            if ch == '"':
+                in_string = True
+                j += 1
+                continue
+
+            if ch == ";":
+                break  # rest of line is a comment
+
+            # --- character literal: skip the next character entirely ---
+            if ch == "\\":
+                j += 2
+                continue
+
+            # --- inside a skipped metadata map: track {/} nesting only ---
+            if meta_depth > 0:
+                if ch == "{":
+                    meta_depth += 1
+                elif ch == "}":
+                    meta_depth -= 1
+                j += 1
+                continue
+
+            # --- normal character dispatch ---
+            if ch == "(":
+                paren_depth += 1
+                if paren_depth >= 2 and not found_bracket:
+                    # Sub-form opened before the param vector — stop sig here
+                    stop = True
+                    break
+                line_buf.append(ch)
+            elif ch == ")":
+                paren_depth -= 1
+                if paren_depth <= 0:
+                    stop = True
+                    break
+                line_buf.append(ch)
+            elif ch == "{":
+                # ^{...} reader-macro metadata: skip and strip preceding '^'
+                if line_buf and line_buf[-1] == "^":
+                    line_buf.pop()
+                    meta_depth = 1
+                elif has_param_vector and paren_depth == 1 and not found_bracket:
+                    # Plain attribute map before the param vector — skip it
+                    meta_depth = 1
+                else:
+                    line_buf.append(ch)
+            elif ch == "}":
+                line_buf.append(ch)
+            elif ch == "[":
+                if has_param_vector and paren_depth == 1:
+                    found_bracket = True
+                bracket_depth += 1
+                line_buf.append(ch)
+            elif ch == "]":
+                bracket_depth -= 1
+                line_buf.append(ch)
+                if found_bracket and bracket_depth == 0 and paren_depth == 1:
+                    # First top-level param vector closed — signature complete
+                    stop = True
+                    break
+            else:
+                line_buf.append(ch)
+
+            j += 1
+
+        line_text = "".join(line_buf).strip()
+        if line_text:
+            parts.append(line_text)
+        if stop:
+            break
+
+    sig = " ".join(parts)
+    sig = re.sub(r"\s+", " ", sig).strip()
+    if sig and not sig.startswith("("):
+        sig = "(" + sig
+    if sig and not sig.endswith(")"):
+        sig += ")"
+    return sig
+
+
+def parse(text: str) -> Iterator[OutlineItem]:
+    lines = text.splitlines()
+    in_str = _string_interior_lines(lines)
+    for i, line in enumerate(lines):
+        if i not in in_str and _TOP_FORM_RE.match(line):
+            sig = _collect_sig(lines, i)
+            form_end = _seek_paren_end(lines, i)
+            _is_comment = lambda _, s: s[0] == ";"
+            start = seek_comment_start(lines, i, _is_comment)
+            yield OutlineItem(start=start + 1, count=form_end - start, signature=sig)

outliner/parsers/csharp.py

@@ -0,0 +1,243 @@
+"""C# outline parser (regex-based)."""
+
+import re
+from collections.abc import Iterator
+
+from outliner.types import OutlineItem
+from outliner.parsers.util import extract_signature, indent_level, seek_comment_start, seek_brace_end
+
+SYNTAX = "csharp"
+EXTENSIONS = (".cs",)
+
+# Detection: require using/namespace AND a type declaration
+_USING_RE = re.compile(r"^\s*(?:global\s+)?using\s+[\w.]+")
+_NS_RE = re.compile(r"^\s*namespace\s+[\w.]+")
+_TYPE_DETECT_RE = re.compile(r"\b(?:class|interface|struct|enum|record|delegate)\s+\w+")
+
+# Type declarations (class, interface, struct, enum, record, delegate)
+_TYPE_RE = re.compile(
+    r"^\s*"
+    r"(?:(?:public|protected|internal|private|static|abstract|sealed|partial|readonly|unsafe|new)\s+)*"
+    r"(?:"
+    r"record\s+(?:class|struct)\s+\w+"
+    r"|record\s+\w+"
+    r"|class\s+\w+"
+    r"|interface\s+\w+"
+    r"|struct\s+\w+"
+    r"|enum\s+\w+"
+    r"|delegate\s+\S+\s+\w+"      # delegate ReturnType Name
+    r")"
+)
+
+# Namespace
+_NAMESPACE_RE = re.compile(r"^\s*(?:file\s+)?namespace\s+[\w.]+")
+
+_CONTROL_FLOW = frozenset({
+    "if", "else", "while", "for", "foreach", "do", "switch", "case",
+    "return", "throw", "catch", "finally", "try", "using", "lock",
+    "fixed", "checked", "unchecked", "sizeof", "typeof", "new",
+    "break", "continue", "goto", "yield",
+})
+
+_STMT_START_RE = re.compile(r"^\s*(?:return|throw|break|continue|goto|yield)\b")
+_ASSIGN_RE = re.compile(r"(?<![=!<>])=(?!=)")
+
+# Explicit interface implementation: "Type IfaceName.Method(" — the name contains a dot
+_EXPLICIT_IFACE_RE = re.compile(
+    r"^\s*"
+    r"(?:(?:public|protected|internal|private|static|abstract|virtual|override|sealed|"
+    r"async|extern|new|partial|readonly|unsafe|volatile)\s+)*"
+    r"(?:~?\w[\w.<>,\[\] ]*?\s+)?"       # optional return type
+    r"(~?(?:\w+\.)+\w+)\s*(?:<[^(]*>)?\s*\("  # qualified name like IFoo.Bar
+)
+
+_METHOD_RE = re.compile(
+    r"^\s*"
+    r"(?:(?:public|protected|internal|private|static|abstract|virtual|override|sealed|"
+    r"async|extern|new|partial|readonly|unsafe|volatile)\s+)*"
+    r"(?:~?\w[\w.<>,\[\] ]*?\s+)?"     # optional return type
+    r"(~?\w+)\s*(?:<[^(]*>)?\s*\("     # method name captured in group 1
+)
+
+# Property: modifiers + type + name + { or => (same line)
+_PROPERTY_RE = re.compile(
+    r"^\s*"
+    r"(?:(?:public|protected|internal|private|static|abstract|virtual|override|sealed|"
+    r"new|readonly|required|unsafe)\s+)*"
+    r"(?:[\w.<>,\[\]?]+\s+){1,3}"
+    r"(\w+)\s*(?:\{|=>)"
+)
+# Property name on its own line (body brace on next line)
+_PROPERTY_NAME_RE = re.compile(
+    r"^\s*"
+    r"(?:(?:public|protected|internal|private|static|abstract|virtual|override|sealed|"
+    r"new|readonly|required|unsafe)\s+)*"
+    r"(?:[\w.<>,\[\]?]+\s+){1,3}"
+    r"(\w+)\s*$"
+)
+
+_ATTR_RE = re.compile(r"^\s*\[")
+
+# Event declarations (excluded — too noisy)
+_EVENT_RE = re.compile(
+    r"^\s*(?:(?:public|protected|internal|private|static|abstract|virtual|"
+    r"override|sealed|new)\s+)*event\b"
+)
+
+
+def _is_preceding_line(_raw: str, s: str) -> bool:
+    """True if line is doc-comment, comment continuation, or attribute preceding a declaration."""
+    return s[:1] in '/*['
+
+
+def _emit_range(lines: list[str], i: int, sig: str, sig_end: int, has_body: bool) -> tuple[OutlineItem, int]:
+    """Build an OutlineItem with comment walk-back and brace-end. Returns (item, body_end)."""
+    start = seek_comment_start(lines, i, _is_preceding_line)
+    end = seek_brace_end(lines, sig_end) if has_body else sig_end + 1
+    return OutlineItem(start=start + 1, count=end - start, signature=sig), end
+
+
+def detect(lines: list[str]) -> bool:
+    """Detect C#: requires using/namespace AND a type declaration."""
+    has_cs_marker = any(_USING_RE.match(l) or _NS_RE.match(l) for l in lines)
+    has_type = any(_TYPE_DETECT_RE.search(l) for l in lines)
+    return has_cs_marker and has_type
+
+
+def _collect_sig(lines: list[str], start: int) -> tuple[str, int, bool]:
+    """Collect a possibly multi-line C# signature.
+
+    Tracks parenthesis depth; stops when parens close and the line ends with
+    { (has body), ; (abstract/interface method), => (expression body), or
+    the closing ) itself (body on next line, detected via look-ahead).
+    Returns (signature, last_sig_line_0based, has_body).
+    """
+    depth = 0
+    paren_opened = False
+    parts: list[str] = []
+    ind = " " * indent_level(lines[start])
+    has_body = False
+    i = start
+    for i in range(start, len(lines)):
+        raw = lines[i]
+        for ch in raw:
+            if ch == "(":
+                depth += 1
+                paren_opened = True
+            elif ch == ")":
+                depth -= 1
+        parts.append(raw.strip())
+        if depth <= 0:
+            if "{" in raw:
+                has_body = True
+                break
+            if raw.rstrip().endswith(";"):
+                break
+            if "=>" in raw:
+                break
+            if paren_opened:
+                # Look ahead for { on the next non-blank line
+                j = i + 1
+                while j < len(lines) and not lines[j].strip():
+                    j += 1
+                if j < len(lines) and lines[j].strip().startswith("{"):
+                    has_body = True
+                break
+    sig = ind + extract_signature(parts, strip="{;")
+    sig = re.sub(r"\s*=>.*$", "", sig).rstrip()
+    return sig, i, has_body
+
+
+def _collect_prop_sig(lines: list[str], start: int) -> tuple[str, int, bool]:
+    """Collect a property signature. Returns (signature, last_line_0based, has_body)."""
+    raw = lines[start]
+    ind = " " * indent_level(raw)
+    s = raw.strip()
+    if "{" in s or "=>" in s:
+        # Strip body portion to get clean signature
+        sig = re.sub(r"\s*(?:\{.*|=>.*)", "", s).strip()
+        return ind + extract_signature([sig]), start, "{" in s
+    # Name-only line; { expected on next line
+    next_idx = start + 1
+    if next_idx < len(lines) and lines[next_idx].strip() == "{":
+        return ind + extract_signature([s]), next_idx, True
+    return ind + extract_signature([s]), start, False
+
+
+def _is_property_line(raw: str, next_line: str = "") -> bool:
+    """Return True if the line looks like a property declaration."""
+    if _STMT_START_RE.match(raw) or _EVENT_RE.match(raw):
+        return False
+    m = _PROPERTY_RE.match(raw)
+    if m:
+        name = m.group(1)
+        if name in _CONTROL_FLOW:
+            return False
+        if re.match(r"\s*\(", raw[m.end(1):]):
+            return False
+        if _ASSIGN_RE.search(raw[m.start():m.end()]):
+            return False
+        return True
+    m2 = _PROPERTY_NAME_RE.match(raw)
+    if m2:
+        name = m2.group(1)
+        if name in _CONTROL_FLOW:
+            return False
+        if _ASSIGN_RE.search(raw):
+            return False
+        if next_line.strip() == "{":
+            return True
+    return False
+
+
+def _is_method_line(raw: str) -> bool:
+    """Return True if the line looks like a method, constructor, or explicit interface impl."""
+    if _STMT_START_RE.match(raw):
+        return False
+    # Try explicit interface implementation first (qualified name like IFoo.Bar)
+    m = _EXPLICIT_IFACE_RE.match(raw)
+    if m:
+        if _ASSIGN_RE.search(raw[m.start():m.end()]):
+            return False
+        return True
+    m = _METHOD_RE.match(raw)
+    if m is None:
+        return False
+    name = m.group(1)
+    if name in _CONTROL_FLOW:
+        return False
+    prefix = raw[:m.start(1)].strip()
+    if not prefix:
+        return False
+    if _ASSIGN_RE.search(raw[m.start():m.end()]):
+        return False
+    return True
+
+
+def parse(text: str) -> Iterator[OutlineItem]:
+    skip_to = 0
+    for i, line in enumerate(lines := text.splitlines()):
+        s = line.strip()
+        if i < skip_to or not s or s[:1] in '/*':
+            pass
+        elif _NAMESPACE_RE.match(line):
+            sig = s.rstrip(";{").strip()
+            start = seek_comment_start(lines, i, _is_preceding_line)
+            end = seek_brace_end(lines, i) if "{" in line else len(lines)
+            yield OutlineItem(start=start + 1, count=end - start, signature=sig)
+        elif _TYPE_RE.match(line):
+            sig, sig_end, has_body = _collect_sig(lines, i)
+            item, _ = _emit_range(lines, i, sig, sig_end, has_body)
+            yield item
+        elif _is_method_line(line):
+            sig, sig_end, has_body = _collect_sig(lines, i)
+            item, end = _emit_range(lines, i, sig, sig_end, has_body)
+            yield item
+            if has_body:
+                skip_to = end
+        elif _is_property_line(line, lines[i + 1] if i + 1 < len(lines) else ""):
+            sig, sig_end, has_body = _collect_prop_sig(lines, i)
+            item, end = _emit_range(lines, i, sig, sig_end, has_body)
+            yield item
+            if has_body:
+                skip_to = end

outliner/parsers/go.py

@@ -0,0 +1,66 @@
+"""Go outline parser (regex-based)."""
+
+import re
+from collections.abc import Iterator
+
+from outliner.types import OutlineItem
+from outliner.parsers.util import extract_signature, seek_comment_start, seek_brace_end
+
+SYNTAX = "go"
+EXTENSIONS = (".go",)
+
+_FUNC_RE = re.compile(r"^func\b")
+_TYPE_RE = re.compile(r"^type\b")
+_PACKAGE_RE = re.compile(r"^package\s+\w+")
+
+
+def detect(lines: list[str]) -> bool:
+    has_package = any(_PACKAGE_RE.match(l) for l in lines)
+    has_go = any(_FUNC_RE.match(l) or _TYPE_RE.match(l) for l in lines)
+    return has_package and has_go
+
+
+def _collect_sig(lines: list[str], start: int, *, until_brace: bool = False) -> tuple[str, int, bool]:
+    """Collect a possibly multi-line Go signature.
+
+    until_brace=True (func): keep collecting until balanced and trailing '{'.
+    until_brace=False (type): stop as soon as depth hits zero.
+    Returns (signature_without_trailing_{, last_sig_line, has_body).
+    """
+    paren_depth = 0
+    bracket_depth = 0
+    parts: list[str] = []
+    has_body = False
+    for i in range(start, len(lines)):
+        raw = lines[i]
+        for ch in raw:
+            if ch == "(":
+                paren_depth += 1
+            elif ch == ")":
+                paren_depth -= 1
+            elif ch == "[":
+                bracket_depth += 1
+            elif ch == "]":
+                bracket_depth -= 1
+        parts.append(raw.strip())
+        if paren_depth <= 0 and bracket_depth <= 0:
+            if raw.rstrip().endswith("{"):
+                has_body = True
+            if has_body or not until_brace:
+                break
+    return extract_signature(parts, strip="{"), i, has_body
+
+
+def parse(text: str) -> Iterator[OutlineItem]:
+    _is_go_comment = lambda _, s: s.startswith("//")
+    for i, line in enumerate(lines := text.splitlines()):
+        if _FUNC_RE.match(line):
+            sig, sig_end, _ = _collect_sig(lines, i, until_brace=True)
+            start = seek_comment_start(lines, i, _is_go_comment)
+            end = seek_brace_end(lines, sig_end)
+            yield OutlineItem(start=start + 1, count=end - start, signature=sig)
+        elif _TYPE_RE.match(line):
+            sig, sig_end, has_body = _collect_sig(lines, i)
+            start = seek_comment_start(lines, i, _is_go_comment)
+            end = seek_brace_end(lines, sig_end) if has_body else sig_end + 1
+            yield OutlineItem(start=start + 1, count=end - start, signature=sig)

outliner/parsers/java.py

@@ -0,0 +1,102 @@
+"""Java outline parser (regex-based)."""
+
+import re
+from collections.abc import Iterator
+
+from outliner.types import OutlineItem
+from outliner.parsers.util import extract_signature, indent_level, seek_comment_start, seek_brace_end
+
+SYNTAX = "java"
+EXTENSIONS = (".java",)
+
+_PACKAGE_RE = re.compile(r"^\s*package\s+[\w.]+\s*;")
+_IMPORT_DETECT_RE = re.compile(r"^\s*import\s+[\w.*]+\s*;")
+
+# Type declarations: class, interface, enum, record, @interface
+_TYPE_RE = re.compile(
+    r"^\s*(?:(?:public|protected|private|static|abstract|final|sealed|non-sealed|strictfp)\s+)*"
+    r"(@\s*interface|interface|class|enum|record)\s+\w+"
+)
+
+# Method/constructor detection — control flow keywords that must not be the captured name
+_CONTROL_FLOW = frozenset({
+    "if", "else", "while", "for", "do", "switch", "case", "try", "catch",
+    "finally", "return", "throw", "assert", "new", "super", "this",
+    "break", "continue", "instanceof", "synchronized",
+})
+
+# Statement starters that make a line definitely not a declaration
+_STMT_START_RE = re.compile(r"^\s*(?:return|throw|break|continue|assert)\b")
+
+# A method/constructor declaration starts with optional modifiers + optional return type + name(
+# Note: generic type-params group uses [^(] (not [^(>]) so backtracking correctly
+# handles nested bounds like <T extends Comparable<T>>.
+_METHOD_RE = re.compile(
+    r"^\s*"
+    r"(?:(?:public|protected|private|static|abstract|final|native|synchronized|strictfp|default|transient|volatile)\s+)*"
+    r"(?:<[^(]*>\s*)?"                               # optional generic type params on method
+    r"(?:(?:void|[\w$][\w$]*(?:<[^(]*>)?(?:\[\])*)\s+)?"  # optional return type
+    r"([\w$]+)\s*\("                                 # method name (captured in group 1)
+)
+
+# Conservative content detection
+_JAVA_DECL_RE = re.compile(r"\b(?:class|interface|enum|record)\s+\w+[^{]*\{")
+_AT_IFACE_RE = re.compile(r"@\s*interface\s+\w+[^{]*\{")
+
+
+def detect(lines: list[str]) -> bool:
+    """Detect Java: requires package/import statement AND a type declaration."""
+    has_java_marker = any(
+        _PACKAGE_RE.match(l) or _IMPORT_DETECT_RE.match(l) for l in lines
+    )
+    has_type = any(_JAVA_DECL_RE.search(l) or _AT_IFACE_RE.search(l) for l in lines)
+    return has_java_marker and has_type
+
+
+def _collect_sig(lines: list[str], start: int) -> tuple[str, int, bool]:
+    """Collect a possibly multi-line Java signature.
+
+    Tracks parenthesis depth; stops when balanced and line ends with { or ;.
+    Returns (signature, last_sig_line_0based, has_body).
+    """
+    depth = 0
+    parts: list[str] = []
+    ind = " " * indent_level(lines[start])
+    has_body = False
+    for i in range(start, len(lines)):
+        line = lines[i]
+        for ch in line:
+            if ch == "(":
+                depth += 1
+            elif ch == ")":
+                depth -= 1
+        parts.append(line.strip())
+        if depth <= 0:
+            if "{" in line:
+                has_body = True
+                break
+            if line.rstrip().endswith(";"):
+                break
+    return ind + extract_signature(parts, strip="{;"), i, has_body
+
+
+def _is_method_line(line: str) -> bool:
+    """Return True if line looks like a method or constructor declaration."""
+    if _STMT_START_RE.match(line):
+        return False
+    m = _METHOD_RE.match(line)
+    return (
+        m is not None
+        and m.group(1) not in _CONTROL_FLOW
+        and bool(line[:m.start(1)].strip())
+    )
+
+
+def parse(text: str) -> Iterator[OutlineItem]:
+    for i, line in enumerate(lines := text.splitlines()):
+        if _TYPE_RE.match(line) or _is_method_line(line):
+            sig, sig_end, has_body = _collect_sig(lines, i)
+            _is_javadoc = lambda _, s: s[0] in "/*@"
+            start = seek_comment_start(lines, i, _is_javadoc)
+            end = seek_brace_end(lines, sig_end) if has_body else sig_end + 1
+            yield OutlineItem(start=start + 1, count=end - start, signature=sig)