simdref 0.0.18__tar.gz → 0.0.19__tar.gz

{simdref-0.0.18/src/simdref.egg-info → simdref-0.0.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simdref
-Version: 0.0.18
+Version: 0.0.19
 Summary: Searchable SIMD intrinsic and instruction reference with CLI, manpages, TUI, and LSP.
 Author: Marco
 License: GPL-3.0-or-later

{simdref-0.0.18 → simdref-0.0.19}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "simdref"
-version = "0.0.18"
+version = "0.0.19"
 description = "Searchable SIMD intrinsic and instruction reference with CLI, manpages, TUI, and LSP."
 readme = "README.md"
 requires-python = ">=3.11"

{simdref-0.0.18 → simdref-0.0.19}/src/simdref/asmline.py

@@ -174,28 +174,96 @@ def c_asm_zone_at(text: str, offset: int) -> str | None:
 
     'template' is an asm(...) template string, 'msvc' an MSVC __asm block
     or line, 'operands' the operand and clobber lists after the first ':'
-    of an asm(...) call. None is plain code. Shares _asm_call_at with
+    of an asm(...) call, 'comment' a C comment, 'string' a string literal
+    that is no asm template. None is plain code. Shares _asm_call_at with
     c_asm_literals, so hover and completion parse the same calls.
     """
+    span = c_span_at(text, offset)
+    if span == "comment":
+        return span
+    zone = c_asm_zone_span_at(text, offset)
+    return zone[0] if zone is not None else span
+
+
+def c_asm_zone_span_at(text: str, offset: int) -> tuple[str, int, int] | None:
+    """(kind, low, high) of the asm zone holding the offset, or None.
+
+    The same walk as c_asm_zone_at. lsp.py reads the bounds: each MSVC
+    __asm statement starts at its own zone's low bound.
+    """
     masked = _mask_c_comments(text)
     index = 0
     while index < len(masked):
         hit = _asm_call_at(masked, index)
         if hit is not None:
             block_end, literals, zones = hit
-            for kind, low, high in zones:
-                if low <= offset <= high:
-                    return kind
-            for start, _body in literals:
-                if start <= offset <= start + len(_body):
-                    return "template"
+            for zone in zones:
+                if zone[1] <= offset <= zone[2]:
+                    return zone
+            for start, body in literals:
+                if start <= offset <= start + len(body):
+                    return "template", start, start + len(body)
             index = block_end
         else:
             index += 1
     return None
 
 
+def c_span_at(text: str, offset: int) -> str | None:
+    """'comment' or 'string' when a cursor offset sits inside one, else None.
+
+    Same scan as _mask_c_comments. A cursor right after the opening
+    delimiter is inside; a cursor after the closing one is outside. An
+    unterminated block comment runs to the end, an unterminated string to
+    the end of its line: both are still being typed. A char literal and a
+    raw string are their own tokens: the double quote inside the char
+    literal '"' never opens a string, and a raw string keeps its quotes.
+    """
+    index = 0
+    while index < offset:
+        line_end = text.find("\n", index)
+        line_end = len(text) if line_end == -1 else line_end
+        if text[index] == "'":
+            end = _char_end(text, index) or line_end + 1
+            if index < offset < end:
+                return "string"
+        elif text[index] == '"':
+            end = _raw_string_end(text, index)
+            if end is None:
+                end = _string_end(text, index) or line_end + 1
+            if index < offset < end:
+                return "string"
+        elif text.startswith("//", index):
+            end = line_end
+            if index + 2 <= offset <= end:
+                return "comment"
+        elif text.startswith("/*", index):
+            close = text.find("*/", index + 2)
+            end = len(text) if close == -1 else close + 2
+            if index + 2 <= offset <= (end if close == -1 else close):
+                return "comment"
+        else:
+            index += 1
+            continue
+        index = max(end, index + 1)
+    return None
+
+
 _QUALIFIERS = ("volatile", "__volatile__", "goto", "inline")
+_ASM_KEYWORDS = ("__asm__", "__asm", "asm")
+
+
+def _asm_keyword_at(text: str, index: int) -> str | None:
+    """The asm keyword at index with word boundaries on both sides, or None."""
+    if index > 0 and (text[index - 1].isalnum() or text[index - 1] == "_"):
+        return None
+    for keyword in _ASM_KEYWORDS:
+        if text.startswith(keyword, index):
+            after = index + len(keyword)
+            tail = text[after : after + 1]
+            if not (tail.isalnum() or tail == "_"):
+                return keyword
+    return None
 
 
 def _asm_call_at(
@@ -214,7 +282,7 @@ def _asm_call_at(
         and (text[index - 1].isalnum() or text[index - 1] == "_")
     ):
         return None
-    for keyword in ("__asm__", "__asm", "asm"):
+    for keyword in _ASM_KEYWORDS:
         if text.startswith(keyword, index):
             break
     else:
@@ -240,9 +308,12 @@ def _asm_call_at(
             return None
         return close + 1, [], [("msvc", cursor + 1, close)]
     if text[cursor : cursor + 1] != "(":
-        # MSVC __asm <insn> line: the instruction runs to end of line.
-        end = index
+        # MSVC __asm <insn>: the statement runs to end of line, or to the
+        # next __asm keyword, which starts its own statement on the row.
+        end = cursor
         while end < len(text) and text[end] != "\n":
+            if _asm_keyword_at(text, end):
+                break
             end += 1
         return end, [], [("msvc", cursor, end)]
     cursor = _skip_space(text, cursor + 1)
@@ -353,14 +424,63 @@ def _string_end(text: str, index: int, spans_lines: bool = False) -> int | None:
     return None
 
 
+def _char_end(text: str, index: int) -> int | None:
+    """The index after the closing quote of the char literal at index, or None.
+
+    A char literal is one token like a string: its quote never opens a
+    string, and an escape pair ("\\'", "\\"") counts as one character.
+    """
+    if text[index : index + 1] != "'":
+        return None
+    cursor = index + 1
+    while cursor < len(text):
+        char = text[cursor]
+        if char == "\\":
+            cursor += 2
+        elif char == "'":
+            return cursor + 1
+        elif char == "\n":
+            return None
+        else:
+            cursor += 1
+    return None
+
+
+def _raw_string_end(text: str, index: int) -> int | None:
+    """The index after the R"delim(...)delim" raw string whose quote is at index.
+
+    None when the shape is not a raw string: the caller then reads the
+    quote as a plain string. An unterminated raw string runs one past the
+    end of the text, because its body spans lines.
+    """
+    if text[index - 1 : index] != "R":
+        return None
+    open_paren = text.find("(", index + 1, index + 18)
+    if open_paren == -1:
+        return None
+    delim = text[index + 1 : open_paren]
+    if len(delim) > 16 or any(char.isspace() or char in "()\\" for char in delim):
+        return None
+    close = text.find(")" + delim + '"', open_paren + 1)
+    return len(text) + 1 if close == -1 else close + len(delim) + 2
+
+
 def _mask_c_comments(text: str) -> str:
-    """Blank C comments to spaces (newlines stay). String literals stay."""
+    """Blank C comments to spaces (newlines stay). Literal tokens stay."""
     out: list[str] = []
     index = 0
     while index < len(text):
         char = text[index]
+        if char == "'":
+            end = _char_end(text, index)
+            if end is not None:
+                out.append(text[index:end])
+                index = end
+                continue
         if char == '"':
-            end = _string_end(text, index)
+            end = _raw_string_end(text, index)
+            if end is None:
+                end = _string_end(text, index)
             if end is not None:
                 out.append(text[index:end])
                 index = end

{simdref-0.0.18 → simdref-0.0.19}/src/simdref/lsp.py

@@ -1420,24 +1420,126 @@ def _completion_candidates(
     return items
 
 
+def _at_mnemonic(before: str, semicolon_is_comment: bool, ptx: bool) -> bool:
+    """True when the cursor ends the first word of an asm statement.
+
+    before is the text from the line start (or the template start) to the
+    cursor. A label, a PTX predicate and the x86 prefix words may come
+    first. A cursor inside a comment is not at a mnemonic.
+    """
+    from simdref.annotate import _strip_prefix_tokens  # annotate imports lsp
+
+    mark = "\0"  # a comment cut removes it, so the cursor is then in a comment
+    probe = asmline.cut_asm_comment(before + mark, _hash_opens_operand)
+    if semicolon_is_comment:
+        probe = asmline.cut_semicolon(probe)
+    else:
+        low, high = asmline.statement_spans(probe)[-1]
+        probe = probe[low:high]
+    rest = probe.lstrip()
+    while True:
+        parts = rest.split(None, 1)
+        if len(parts) == 2 and (parts[0].endswith(":") or (ptx and parts[0].startswith("@"))):
+            rest = parts[1]
+        else:
+            break
+    word = _strip_prefix_tokens(rest).removesuffix(mark)
+    return rest.endswith(mark) and (not word or asmline.word_at(word, len(word)) == word)
+
+
+def _msvc_before(text: str, offset: int) -> str:
+    """The MSVC __asm statement text before the cursor.
+
+    Each __asm keyword and each row inside a brace block starts a new
+    statement. The asm zone marks the keyword case at its low bound; the
+    row start bounds the brace case.
+    """
+    start = text.rfind("\n", 0, offset) + 1
+    zone = asmline.c_asm_zone_span_at(text, offset)
+    if zone is not None:
+        start = max(start, zone[1])
+    return text[start:offset]
+
+
+def _objdump_mnemonic_column(line: str) -> int | None:
+    """Start column of the mnemonic on an objdump address line, else None.
+
+    Reuses annotate's objdump line split: its rest starts at the mnemonic,
+    after the address and byte columns.
+    """
+    from simdref.annotate import _parse_objdump_instr  # annotate imports lsp
+
+    parsed = _parse_objdump_instr(line)
+    if parsed is None:
+        return None
+    return len(line.rstrip()) - len(parsed[1])
+
+
+def _template_before(text: str, offset: int) -> str | None:
+    """The asm statement text before the cursor inside an asm template string."""
+    for start, body in asmline.c_asm_literals(text):
+        if start <= offset <= start + len(body):
+            spaced = body[: offset - start].replace("\\t", " ")
+            return spaced[asmline.statement_spans(spaced)[-1][0] :]
+    return None
+
+
 def _completion_items(
-    conn, text: str, language_id: str, uri: str, prefix: str, line: int, character: int
+    conn,
+    text: str,
+    language_id: str,
+    uri: str,
+    prefix: str,
+    line: int,
+    character: int,
+    trigger_kind: int | None = None,
+    trigger_char: str | None = None,
 ) -> list[dict]:
     """Completion items for one cursor position.
 
-    Assembly documents keep the full pool. In C and C++ the pool follows
-    the cursor: mnemonics only inside an asm template string, an MSVC
-    __asm block or an MSVC __asm line; no simdref items in the operand and
-    clobber lists; intrinsics only everywhere else.
+    Completion answers only where the item kind can be written. Nothing
+    inside a comment or a plain string, nothing for an empty prefix unless
+    the user invoked completion by hand (trigger kind 1), nothing from a
+    "." trigger outside PTX names. Assembly and PTX documents offer items
+    at the mnemonic position of a statement only. In C and C++ the pool
+    follows the cursor: mnemonics only inside an asm template string, an
+    MSVC __asm block or an MSVC __asm line; no simdref items in the operand
+    and clobber lists; intrinsics only everywhere else.
     """
+    if not prefix and trigger_kind != 1:
+        return []
     ptx = _is_ptx_doc(language_id, uri) or _is_cuda_doc(language_id, uri)
     cuda = _is_cuda_doc(language_id, uri)
-    if _is_ptx_doc(language_id, uri):
-        return _completion_candidates(conn, prefix, kinds=_MNEMONIC_KINDS, ptx=True, cuda=cuda)
     if not _is_c_doc(language_id, uri):
-        return _completion_candidates(conn, prefix, ptx=ptx, cuda=cuda)
-    zone = asmline.c_asm_zone_at(text, _offset_at(text, line, character))
-    if zone == "operands":
+        is_ptx = _is_ptx_doc(language_id, uri)
+        if trigger_char == "." and not is_ptx:
+            return []
+        lines = text.split("\n")
+        source_line = lines[line].rstrip("\r") if line < len(lines) else ""
+        before = source_line[: _code_point_index(source_line, character)]
+        cut = _objdump_mnemonic_column(source_line)
+        if cut is not None:
+            # An objdump address row names its mnemonic after the address
+            # and byte columns; an item fits at that column only.
+            if len(before) < cut:
+                return []
+            before = before[cut:]
+        if not _at_mnemonic(before, _semicolon_is_comment(language_id, uri), is_ptx):
+            return []
+        return _completion_candidates(
+            conn, prefix, kinds=_MNEMONIC_KINDS if is_ptx else None, ptx=ptx, cuda=cuda
+        )
+    offset = _offset_at(text, line, character)
+    zone = asmline.c_asm_zone_at(text, offset)
+    if zone in ("operands", "comment", "string"):
+        return []
+    if trigger_char == "." and not (cuda and zone == "template"):
+        return []
+    if zone == "template":
+        before = _template_before(text, offset)
+        if before is None or not _at_mnemonic(before, False, cuda):
+            return []
+    elif zone == "msvc" and not _at_mnemonic(_msvc_before(text, offset), True, False):
         return []
     kinds = _MNEMONIC_KINDS if zone in ("template", "msvc") else _INTRINSIC_KINDS
     return _completion_candidates(conn, prefix, kinds=kinds, ptx=ptx, cuda=cuda)
@@ -1738,7 +1840,7 @@ def main() -> int:
                             "inlayHintProvider": True,
                             "completionProvider": {
                                 "resolveProvider": False,
-                                "triggerCharacters": ["_", ".", "m", "v"],
+                                "triggerCharacters": ["_", "."],
                             },
                         }
                     },
@@ -1852,8 +1954,19 @@ def main() -> int:
             language_id = session.languages.get(uri, "")
             line, character = params["position"]["line"], params["position"]["character"]
             prefix = _line_prefix(text, line, character)
+            context = params.get("context") or {}
             items = (
-                _completion_items(conn, text, language_id, uri, prefix, line, character)
+                _completion_items(
+                    conn,
+                    text,
+                    language_id,
+                    uri,
+                    prefix,
+                    line,
+                    character,
+                    context.get("triggerKind"),
+                    context.get("triggerCharacter"),
+                )
                 if conn
                 else []
             )

{simdref-0.0.18 → simdref-0.0.19/src/simdref.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simdref
-Version: 0.0.18
+Version: 0.0.19
 Summary: Searchable SIMD intrinsic and instruction reference with CLI, manpages, TUI, and LSP.
 Author: Marco
 License: GPL-3.0-or-later

{simdref-0.0.18 → simdref-0.0.19}/tests/test_lsp_ptx.py

@@ -239,6 +239,25 @@ class LspPtxTests(unittest.TestCase):
         self.assertEqual(kinds, {3})
         self.assertNotIn("frob d, [a]", [item["label"] for item in items])
 
+    def test_completion_ptx_dotted_name_still_completes(self):
+        # A hand-typed "frob." and a "." trigger both complete in a .ptx file.
+        text = "frob.\n"
+        self.assertTrue(self.server.completion(PTX_URI, "ptx", text, 0, 5))
+        msg = self.server.request(
+            "textDocument/completion",
+            {
+                "textDocument": {"uri": PTX_URI},
+                "position": {"line": 0, "character": 5},
+                "context": {"triggerKind": 2, "triggerCharacter": "."},
+            },
+        )
+        self.assertTrue(msg["result"]["items"])
+
+    def test_completion_ptx_operand_and_comment_give_no_items(self):
+        text = "frob.f32 %f1, frob\n// frob comment\n"
+        self.assertEqual(self.server.completion(PTX_URI, "ptx", text, 0, 18), [])
+        self.assertEqual(self.server.completion(PTX_URI, "ptx", text, 1, 7), [])
+
     def test_completion_dot_prefix_unchanged_outside_ptx(self):
         # Control: a dotted prefix in a .s document keeps origin/main's
         # empty answer. The dot rule is ptx-only (review finding 1).

{simdref-0.0.18 → simdref-0.0.19}/tests/test_lsp_stdio.py

@@ -1038,12 +1038,20 @@ C_COMPLETION_INTRINSICS = [
         "<arm_neon.h>",
         "arm",
     ),
+    _c_intrinsic(
+        "_mm256_cmpeq_epi8",
+        "__m256i _mm256_cmpeq_epi8 (__m256i a, __m256i b)",
+        "Compare packed 8-bit integers.",
+        "<immintrin.h>",
+        "x86",
+    ),
 ]
 C_COMPLETION_INSTRUCTIONS = [
     _c_insn("vaddps", "VADDPS (XMM, XMM, XMM)", "Add packed single precision values."),
     _c_insn("vmulps", "VMULPS (XMM, XMM, XMM)", "Multiply packed single precision values."),
     _c_insn("vmovaps", "VMOVAPS (XMM, XMM)", "Move aligned packed single precision values."),
     _c_insn("mov", "MOV (R64, R64)", "Move."),
+    _c_insn("cbw", "CBW (X86)", "Convert byte to word."),
 ]
 
 # One document per zone. Lines: 3-4 multi-line asm template, 5 asm with the
@@ -1159,10 +1167,9 @@ class LspCCompletionTests(unittest.TestCase):
         self.assertEqual(self._kinds(items), {3})
         self.assertEqual(self._labels(items), ["vaddq_f32"])
 
-    def test_comment_gives_intrinsics_only(self):
+    def test_comment_gives_no_items(self):
         items = self.server.completion(C_COMPLETION_URI, 12, self._col(12, "vaddps", 2))
-        self.assertEqual(self._kinds(items), {3})
-        self.assertEqual(self._labels(items), ["vaddq_f32"])
+        self.assertEqual(items, [])
 
     def test_plain_string_gives_no_mnemonics(self):
         items = self.server.completion(C_COMPLETION_URI, 11, self._col(11, "mov", 1))
@@ -1184,6 +1191,208 @@ class LspCCompletionTests(unittest.TestCase):
         )
 
 
+SCOPE_C_URI = "file:///tmp/simdref_lsp_scope.c"
+SCOPE_C_TEXT = (
+    "// vaddps comment\n"
+    "/* _mm */\n"
+    'char *s = "_mm";\n'
+    "int y = foo.\n"
+    "_mm_add\n"
+    'void g(void) { asm("vadd %%xmm0, %%xmm1\\n\\tmov %%eax, vadd"); }\n'
+)
+SCOPE_ASM_URI = "file:///tmp/simdref_lsp_scope.s"
+SCOPE_ASM_TEXT = "# vadd comment\nvadd ymm0, vadd\n  vadd\nloop: vadd\n"
+SCOPE_NASM_URI = "file:///tmp/simdref_lsp_scope.asm"
+SCOPE_NASM_TEXT = "; vadd comment\nvadd ymm0, ymm1 ; vadd\n"
+
+
+class LspCompletionScopeTests(unittest.TestCase):
+    """Completion answers only where an item can be written."""
+
+    def setUp(self):
+        self.server = _Server(_c_completion_catalog())
+        self.addCleanup(self.server.stop)
+        self.caps = self.server.start()
+        self.server.open(SCOPE_C_URI, "c", SCOPE_C_TEXT)
+        self.server.open(SCOPE_ASM_URI, "asm", SCOPE_ASM_TEXT)
+        self.server.open(SCOPE_NASM_URI, "nasm", SCOPE_NASM_TEXT)
+
+    def _at(self, uri, text, line, marker, typed, occurrence=0):
+        row = text.split("\n")[line]
+        index = -1
+        for _ in range(occurrence + 1):
+            index = row.index(marker, index + 1)
+        return self.server.completion(uri, line, index + typed)
+
+    def _labels(self, items):
+        return [item["label"] for item in items]
+
+    def test_letters_are_not_trigger_characters(self):
+        triggers = self.caps["completionProvider"]["triggerCharacters"]
+        self.assertEqual(triggers, ["_", "."])
+
+    def test_c_line_comment_gives_no_items(self):
+        self.assertEqual(self._at(SCOPE_C_URI, SCOPE_C_TEXT, 0, "vaddps", 2), [])
+
+    def test_c_block_comment_gives_no_items(self):
+        self.assertEqual(self._at(SCOPE_C_URI, SCOPE_C_TEXT, 1, "_mm", 3), [])
+
+    def test_c_string_gives_no_items(self):
+        self.assertEqual(self._at(SCOPE_C_URI, SCOPE_C_TEXT, 2, "_mm", 3), [])
+
+    def test_dot_after_identifier_in_c_gives_no_items(self):
+        params = {
+            "textDocument": {"uri": SCOPE_C_URI},
+            "position": {"line": 3, "character": len("int y = foo.")},
+            "context": {"triggerKind": 2, "triggerCharacter": "."},
+        }
+        result = self.server.request("textDocument/completion", params)["result"]
+        self.assertEqual(result["items"], [])
+
+    def test_empty_prefix_gives_no_items_unless_invoked_by_hand(self):
+        def ask(kind):
+            params = {
+                "textDocument": {"uri": SCOPE_C_URI},
+                "position": {"line": 3, "character": len("int y = ")},
+                "context": {"triggerKind": kind},
+            }
+            return self.server.request("textDocument/completion", params)["result"]["items"]
+
+        self.assertEqual(ask(2), [])
+        self.assertTrue(ask(1))
+
+    def test_c_plain_code_still_completes_intrinsics(self):
+        items = self._at(SCOPE_C_URI, SCOPE_C_TEXT, 4, "_mm_add", 7)
+        self.assertEqual(self._labels(items), ["_mm_add_ps"])
+
+    def test_c_asm_template_keeps_mnemonics_at_statement_start(self):
+        items = self._at(SCOPE_C_URI, SCOPE_C_TEXT, 5, "vadd", 4)
+        self.assertEqual({item["kind"] for item in items}, {14})
+        self.assertTrue(items)
+
+    def test_c_asm_template_operand_gives_no_items(self):
+        self.assertEqual(self._at(SCOPE_C_URI, SCOPE_C_TEXT, 5, "vadd", 4, occurrence=1), [])
+
+    def test_asm_comment_lines_give_no_items(self):
+        self.assertEqual(self._at(SCOPE_ASM_URI, SCOPE_ASM_TEXT, 0, "vadd", 4), [])
+        self.assertEqual(self._at(SCOPE_NASM_URI, SCOPE_NASM_TEXT, 0, "vadd", 4), [])
+        self.assertEqual(self._at(SCOPE_NASM_URI, SCOPE_NASM_TEXT, 1, "vadd", 4, occurrence=1), [])
+
+    def test_asm_operand_position_gives_no_items(self):
+        self.assertEqual(self._at(SCOPE_ASM_URI, SCOPE_ASM_TEXT, 1, "vadd", 4, occurrence=1), [])
+
+    def test_asm_mnemonic_position_still_completes(self):
+        for line, marker in ((1, "vadd"), (2, "vadd"), (3, "vadd")):
+            items = self._at(SCOPE_ASM_URI, SCOPE_ASM_TEXT, line, marker, 4)
+            self.assertIn("VADDPS (XMM, XMM, XMM)", self._labels(items), (line, marker))
+
+
+REVIEW_QUOTE_URI = "file:///tmp/simdref_lsp_review_quote.c"
+REVIEW_QUOTE_TEXT = (
+    "x = '\"'; _mm_add\n"
+    "__m256i q = _mm256_cmpeq_epi8(in, _mm256_set1_epi8('\"')); __m256i b = _mm256_cmpeq\n"
+    "if (c=='\"') s = \"_mm\n"
+    "char c = 'm\n"
+    "y = '\\''; _mm_add\n"
+    'z = "a\\"_mm\n'
+)
+REVIEW_RAW_URI = "file:///tmp/simdref_lsp_review_raw.cpp"
+REVIEW_RAW_TEXT = 'auto s = R"(_mm_add\nstill _mm_add\n)" ;\nauto t = R"x(a"b)x"; _mm_add\n'
+REVIEW_MSC_URI = "file:///tmp/simdref_lsp_review_msvc.c"
+REVIEW_MSC_TEXT = (
+    "void f(){ __asm { vaddps xmm0, xmm1 }\n"
+    "}\n"
+    "void g(){ __asm vadd\n"
+    "}\n"
+    "void h(){ __asm mov eax, 1 __asm vadd\n"
+    "}\n"
+)
+REVIEW_OBJ_URI = "file:///tmp/simdref_lsp_review_obj.s"
+REVIEW_OBJ_TEXT = "  401000:\tc5 f4 58 c2          \tvadd ymm0, ymm1\n"
+
+
+class LspCompletionReviewTests(unittest.TestCase):
+    """The review round repros. A char literal and a raw string are their
+    own tokens. Each MSVC __asm statement starts a mnemonic position. An
+    objdump row offers items at the mnemonic column only. On the fixture
+    catalog, not the ambient one."""
+
+    def setUp(self):
+        self.server = _Server(_c_completion_catalog())
+        self.addCleanup(self.server.stop)
+        self.server.start()
+        self.server.open(REVIEW_QUOTE_URI, "c", REVIEW_QUOTE_TEXT)
+        self.server.open(REVIEW_RAW_URI, "cpp", REVIEW_RAW_TEXT)
+        self.server.open(REVIEW_MSC_URI, "c", REVIEW_MSC_TEXT)
+        self.server.open(REVIEW_OBJ_URI, "asm", REVIEW_OBJ_TEXT)
+
+    def _labels(self, items):
+        return [item["label"] for item in items]
+
+    def _end(self, uri, text, line):
+        return self.server.completion(uri, line, len(text.split("\n")[line]))
+
+    def _at(self, uri, text, line, marker, typed, occurrence=0):
+        row = text.split("\n")[line]
+        index = -1
+        for _ in range(occurrence + 1):
+            index = row.index(marker, index + 1)
+        return self.server.completion(uri, line, index + typed)
+
+    def test_char_literal_quote_keeps_the_rest_of_the_row_code(self):
+        items = self._end(REVIEW_QUOTE_URI, REVIEW_QUOTE_TEXT, 0)
+        self.assertEqual(self._labels(items), ["_mm_add_ps"])
+
+    def test_char_literal_quote_before_an_intrinsic_name(self):
+        items = self._end(REVIEW_QUOTE_URI, REVIEW_QUOTE_TEXT, 1)
+        self.assertEqual(self._labels(items), ["_mm256_cmpeq_epi8"])
+
+    def test_char_literal_quote_before_a_string_keeps_the_string(self):
+        self.assertEqual(self._end(REVIEW_QUOTE_URI, REVIEW_QUOTE_TEXT, 2), [])
+
+    def test_char_literal_tokens_stay_closed(self):
+        self.assertEqual(self._end(REVIEW_QUOTE_URI, REVIEW_QUOTE_TEXT, 3), [])
+        items = self._end(REVIEW_QUOTE_URI, REVIEW_QUOTE_TEXT, 4)
+        self.assertEqual(self._labels(items), ["_mm_add_ps"])
+        self.assertEqual(self._end(REVIEW_QUOTE_URI, REVIEW_QUOTE_TEXT, 5), [])
+
+    def test_raw_string_keeps_its_body_on_the_next_rows(self):
+        self.assertEqual(self._end(REVIEW_RAW_URI, REVIEW_RAW_TEXT, 0), [])
+        self.assertEqual(self._end(REVIEW_RAW_URI, REVIEW_RAW_TEXT, 1), [])
+        uri = "file:///tmp/simdref_lsp_review_raw_eof.cpp"
+        text = 'auto s = R"(_mm_add'
+        self.server.open(uri, "cpp", text)
+        self.assertEqual(self.server.completion(uri, 0, len(text)), [])
+
+    def test_raw_string_delimited_body_keeps_its_quotes(self):
+        items = self._end(REVIEW_RAW_URI, REVIEW_RAW_TEXT, 3)
+        self.assertEqual(self._labels(items), ["_mm_add_ps"])
+
+    def test_msvc_brace_statement_completes_at_the_mnemonic(self):
+        items = self._at(REVIEW_MSC_URI, REVIEW_MSC_TEXT, 0, "vaddps", 6)
+        self.assertEqual(self._labels(items), ["VADDPS (XMM, XMM, XMM)"])
+        self.assertEqual(self._at(REVIEW_MSC_URI, REVIEW_MSC_TEXT, 0, "xmm1", 2), [])
+
+    def test_msvc_row_statement_after_code_completes(self):
+        items = self._end(REVIEW_MSC_URI, REVIEW_MSC_TEXT, 2)
+        self.assertEqual(self._labels(items), ["VADDPS (XMM, XMM, XMM)"])
+
+    def test_msvc_second_statement_on_one_row_completes(self):
+        items = self._end(REVIEW_MSC_URI, REVIEW_MSC_TEXT, 4)
+        self.assertEqual(self._labels(items), ["VADDPS (XMM, XMM, XMM)"])
+        items = self._at(REVIEW_MSC_URI, REVIEW_MSC_TEXT, 4, "mov", 3)
+        self.assertEqual(self._labels(items), ["MOV (R64, R64)"])
+        self.assertEqual(self._at(REVIEW_MSC_URI, REVIEW_MSC_TEXT, 4, "eax", 2), [])
+
+    def test_objdump_row_completes_at_the_mnemonic_column(self):
+        items = self._at(REVIEW_OBJ_URI, REVIEW_OBJ_TEXT, 0, "vadd", 4)
+        self.assertEqual(sorted(self._labels(items)), ["VADDPS (XMM, XMM, XMM)", "vaddq_f32"])
+
+    def test_objdump_byte_column_gives_no_items(self):
+        self.assertEqual(self._at(REVIEW_OBJ_URI, REVIEW_OBJ_TEXT, 0, "c5", 1), [])
+        self.assertEqual(self._at(REVIEW_OBJ_URI, REVIEW_OBJ_TEXT, 0, "ymm0", 2), [])
+
+
 class MissingCatalogTests(unittest.TestCase):
     def test_missing_catalog_sends_show_message_once(self):
         server = _Server(MISSING_CATALOG)