ISSUE DESCRIPTION unused-class-members FP: methods called only from Svelte <template>…
- User
ISSUE DESCRIPTION
unused-class-members FP: methods called only from Svelte member expressions False positive on 2.84.0. Class methods called only from a Svelte
<template>via a member expression (for exampleresultState.pin(...)in markup) are reported asunused-class-member. Fallow tracks template-visible identifiers but not member-expression method calls on a bound instance inside Svelte markup.Repro (2.84.0): asciimoo/hister.
ResultState.onOpen,.pin,.updateLabel, and.addSkipRuleare each invoked from.sveltetemplates (resultState.pin(...)inResultActionsMenu.svelte) yet reported unused. The repo currently setsrules.unused-class-members: "off"to work around it.Expected: credit a method called as
<local>.<method>(...)inside a Svelte<template>when<local>resolves to an instance of the class, parallel to the existing Vue/Angular template member-access tracking.Interface
No new interfaces are introduced.
ADDITIONAL ADVICE
Since you are given a git repository, you can use git commands to simplify your work. For example, if you made a mistake and want to revert your changes, you can use
git checkout <file>to restore the file to its original state. You can also reset all changes in the repository usinggit reset --hardcommand. Additionally, you can usegit stashandgit stash popto temporarily save your changes and restore them later. Finally, you can see the changes that you've made (which will be submitted when you callsubmit) usinggit statusorgit diffcommands. However you don't need to usegit addorgit commitbefore submitting your changes. In fact,submitonly submits currently unstaged changes because it usesgit diffto get the changes that need to be submitted.CHECKLIST
Before submitting your solution, please go over the following checklist and make sure you've done everything:
- If an error was reported in the issue description, I have successfully reproduced it.
- If an error was reported in the issue description, I have confirmed that my fix resolves the error.
- I have thought about edge cases and made sure my fix handles them as well.
- I have run existing tests in the repository that might have been affected by the change I made and confirmed that they pass. I want you to list every bullet from this checklist and write your reasoning for why you think you did it or didn't need to.
Repository has been uploaded and your shell is currently at the repository root. Time to solve the issue!
(Current directory: /fallow, current file: none) bash-$
- Assistant
I'll start by exploring the repository structure to understand what we're working with. Let's first check the current directory and see the overall layout.
- Assistant
Let me explore the repository structure more thoroughly.
- Assistant
This is a Rust project (Cargo.toml, crates directory). Let me explore the crate structure.
- Assistant
This looks like a Rust project called "Fallow" - a linting tool. The issue is about false positives in
unused-class-membersrule, specifically for methods called only from Svelte<template>via member expressions (e.g.,resultState.pin(...)in markup).Let me understand the issue:
- Class methods called from Svelte templates via member expressions (like
resultState.pin(...)) are incorrectly reported as unused - The tool tracks template-visible identifiers but not member-expression method calls on bound instances inside Svelte markup
- The fix should credit a method called as
<local>.<method>(...)inside a Svelte<template>when<local>resolves to an instance of the class
Let me first understand the repository structure better, especially the part that handles unused class members and template analysis.
- Class methods called from Svelte templates via member expressions (like
- Assistant
This is a Rust-based linting tool called "fallow". Let me look for the unused-class-members rule implementation and the Svelte template handling.
- Assistant
Let me look at the main analysis file for unused members:
- Assistant
Let me search for how templates are handled in the codebase:
- Assistant
Let me look at the Svelte template handler:
- Assistant
Let me look at the template_usage module to understand what TemplateUsage tracks.
- Assistant
Let me examine the template_usage.rs file to understand what TemplateUsage tracks.
- Assistant
Let me look at how template member accesses flow into the unused_members analysis:
- Assistant
Let me look at how the SFC template information is integrated:
- Assistant
Let me understand the issue better. The problem is about "unused-class-members" false positives. Class methods called only from Svelte
<template>via a member expression (e.g.,resultState.pin(...)in markup) are reported as unused. The tool tracks template-visible identifiers but not member-expression method calls on a bound instance inside Svelte markup.Let me look at how the SFC template processing works for Svelte, and how template member accesses are tracked for class members.
- Assistant
Let me understand the flow better. Let me look at
apply_template_usageand how template member accesses are merged into module info: - Assistant
Let me look at the
apply_template_usagefunction: - Assistant
Let me now look at the shared template utilities to understand how member accesses are extracted from template expressions:
- Assistant
Now I need to understand the issue better. Let me look at how
bound_targetsare populated for Svelte SFCs and how they flow into the template usage analysis. - Assistant
Let me look at how
template_visible_bound_targetsis populated: - Assistant
Let me look at how the Svelte template scanner handles expressions like
resultState.pin(...): - Assistant
Let me look at the
analyze_template_snippet_with_bound_targetsfunction to understand how it handles member accesses: - Assistant
Now let me look at how
binding_target_namesworks and what it extracts: - Assistant
Let me look at the full
apply_tagfunction in the Svelte template scanner to see how expressions likeresultState.pin(...)are handled: - Assistant
Now let me look at how HTML attributes with event handlers are processed in Svelte:
- Assistant
Let me look at the test that seems relevant:
- Assistant
Good, I can see the test
event_handler_arrow_member_access_maps_script_instance_to_classwhich tests the exact scenario. Let me now look at how template member accesses flow into the unused_members analysis. Let me look at the flow from template to unused member detection: - Assistant
Let me look at how the unused_members analysis processes member_accesses, especially around the template bridging logic.
- Assistant
Let me look at how
find_unused_membershandles template member accesses for Svelte SFC files. Let me search for how Svelte template member accesses flow into the analysis: - Assistant
Let me look at how the extract phase collects member accesses and bound targets for SFCs:
- Assistant
Let me look at how
find_unused_membersprocesses member accesses: - Assistant
Let me understand how the analysis resolves member accesses from the module's
member_accesses: - Assistant
Let me look at the main
find_unused_membersfunction: - Assistant
Let me understand how the member accesses get resolved. Let me look at
local_to_export_keysand how theresolve_bound_member_accessesis handled in the visitor: - Assistant
Let me look at the
resolve_bound_member_accessesmethod to see how template member accesses are resolved for the unused_members analysis: - Assistant
Let me look at the full
resolve_bound_member_accessesmethod and how template member accesses from SFCs flow through: - Assistant
Let me look at how
merge_script_into_modulepopulatestemplate_visible_bound_targetsand understand the whole flow: - Assistant
Let me look at the
merge_intomethod and how template member accesses are integrated into the ModuleInfo: - Assistant
Now let me understand the full flow. Let me look at how SFC member accesses get into the resolved module that unused_members uses:
- Assistant
Let me look at how the flow works from SFC parsing to the template scanner. Let me also check what
binding_target_names()returns for a typical Svelte script: - Assistant
Let me now understand the issue better. Let me look at what existing tests are related to Svelte and unused class members:
- Assistant
Let me look at the false_positive_fixes test to see if there are any Svelte-related tests:
- Assistant
Let me look at the SFC parsing tests to see how they test the template member access flow:
- Assistant
Let me look at the Svelte fixture directory to understand the test setup:
- Assistant
Let me look at the App.svelte file to see how the test fixture works:
- Assistant
Let me run the existing Svelte test to verify it passes:
- Assistant
The test passes. Let me now understand the specific issue better. Let me look at how Vue template scanning handles member accesses, and compare it with Svelte:
- Assistant
Now let me look at how
const counter = new Counter()is detected and howbinding_target_namesgets populated. Let me trace through the visitor logic: - Assistant
Let me look at the specific code that handles
const x = new ClassName(...): - Assistant
Let me now look at how the
apply_markup_tagfunction in Svelte handles attribute expressions: - Assistant
Let me look at
merge_attribute_value_usage: - Assistant
Let me look at the merge_attribute_value_usage function.
- Assistant
Let me look at the utils.ts file that's imported in the Svelte test fixture:
- Assistant
Now let me look at the full Svelte template to understand how the test works and think about what might be missing:
- Assistant
Let me look at the
build_local_to_export_keysfunction: - Assistant
Let me look at this function.
- Assistant
Let me try a different approach. Let me look at how the template member accesses flow from the SFC parsing into the analysis. Let me check if there's something wrong with the flow:
- Assistant
Let me look at how the SFC module starts with empty member_accesses and how they get populated:
- Assistant
Let me look at the graph construction to see how
member_accessesflow through: - Assistant
Let me check git log for recent changes related to Svelte template member access:
- Assistant
Let me look for commits related to Svelte template member access:
- Assistant
Let me look at the most relevant commit:
- Assistant
OK so it looks like the fix was already made in commit
cadeb111. Let me check if this commit is in the current HEAD or if it's only in a branch: - Assistant
Let me check if
cadeb111is an ancestor of HEAD: - Assistant
OK so the fix commit
cadeb111IS an ancestor of HEAD. Let me run all the SFC-related tests to see if everything currently passes: - Assistant
Let me think about this differently. Let me look at the referenced issue in more detail and try to understand the exact failure scenario. Let me search for related tests that already exist:
- Assistant
Let me try a different approach - let me create a minimal repro case to understand the issue better. Let me look at the
apply_markup_tagfunction to understand how attribute values are processed, specifically looking at the issue from the perspective of the<button onclick={() => resultState.pin(...)}>Pin</button>pattern: - Assistant
Let me re-read the issue more carefully. Let me understand the problem by looking at what exact flow might fail. Let me trace through how member accesses from Svelte SFC templates flow into the analysis:
- Assistant
Let me look at the full context of that line.
- Assistant
Let me look at the Vue test that's similar:
- Assistant
Let me understand this issue better. Let me check the Angular template members test for comparison since it seems to work:
- Assistant
Let me look at
parse_tag_attrsto understand how attribute values are parsed: - Assistant
Let me take a step back and look at the CLAUDE.md for more context about the project:
- Assistant
Let me look at the CONTEXT.md and related files for understanding:
- Assistant
Let me run the specific Svelte test to verify:
- Assistant
The test passed! Let me now carefully re-read the issue description:
"unused-class-members FP: methods called only from Svelte
<template>member expressions""Fallow tracks template-visible identifiers but not member-expression method calls on a bound instance inside Svelte markup."
OK, so the existing test shows
counter.bump()andcounter.valuework. But the issue mentionsresultState.pin(...)in the hister repo. Let me think about what could be different.Wait, let me look at this more carefully. The existing test tests
onclick={() => counter.bump()}which is an arrow function inside an event handler. But what about direct template expressions?Let me look at the template scanner tests more carefully to see what's covered. The test
event_handler_arrow_member_access_maps_script_instance_to_classtests:onclick={() => counter.bump()}- arrow function in event handler{counter.value}- direct template expression
These both work. So what's different in the hister case?
Wait, let me re-read the issue description more carefully:
"Fallow tracks template-visible identifiers but not member-expression method calls on a bound instance inside Svelte markup."
Maybe the issue is that the existing tests already show the feature works, but the issue is filed about a specific case that ISN'T handled. Let me look at what specific case might not be handled.
Actually, hold on. Let me look at the issue title again: "unused-class-members FP: methods called only from Svelte
<template>member expressions"And the description says: "Fallow tracks template-visible identifiers but not member-expression method calls on a bound instance inside Svelte markup."
Maybe "template-visible identifiers" refers to identifiers that appear in the template (like
counterby itself), and "member-expression method calls" refers tocounter.bump(). And the claim is that the tool trackscounteras a used identifier but doesn't trackcounter.bump()as a method call on the Counter class.But the test already shows this works! Unless the test was added as part of the fix that resolves this exact issue.
Let me check: the commit
cadeb111(which added the test) says "fix(svelte): credit @attach directives and script-instance member access". The commit message mentions "Closes #200".So the fix for this issue (credit script-instance member access in Svelte templates) has ALREADY been committed. Let me verify by checking what version that commit is in:
Actually wait, the issue says "False positive on 2.84.0" and the workspace version is 2.84.0. And
cadeb111is an ancestor of HEAD. So the fix is already in the codebase!But then why is the issue filed? Maybe there's a DIFFERENT aspect of the issue that's not fixed. Let me re-read the issue one more time very carefully...
"unused-class-members FP: methods called only from Svelte
<template>member expressions""False positive on 2.84.0. Class methods called only from a Svelte
<template>via a member expression (for exampleresultState.pin(...)in markup) are reported asunused-class-member. Fallow tracks template-visible identifiers but not member-expression method calls on a bound instance inside Svelte markup.""Repro (2.84.0): asciimoo/hister.
ResultState.onOpen,.pin,.updateLabel, and.addSkipRuleare each invoked from.sveltetemplates (resultState.pin(...)inResultActionsMenu.svelte) yet reported unused. The repo currently setsrules.unused-class-members: "off"to work around it.""Expected: credit a method called as
<local>.<method>(...)inside a Svelte<template>when<local>resolves to an instance of the class, parallel to the existing Vue/Angular template member-access tracking."Hmm, maybe the fix that was already committed doesn't fully handle the hister case. Let me look at what patterns might not be handled.
Looking at the Svelte template scanner, it handles:
{counter.value}- direct curly expressiononclick={() => counter.bump()}- event handler with arrow function{#if counter.value}- if condition{#each ...} ... {counter.value}- inside each blocks- etc.
But what about:
onclick={resultState.pin}- passing method reference without calling itonclick={() => { resultState.pin(); resultState.updateLabel(); }}- multiple calls3. Complex expressions like{resultState.items.map(item => resultState.pin(item))}
All of these should be handled because the expression is parsed by the oxc parser and member accesses are extracted.
Wait, let me think about this differently. Maybe the issue is not in the template scanner at all, but in how the module graph resolves the member accesses.
Actually, I just realized something. The commit
cadeb111addsbound_targetsto the Svelte template scanner. Before this commit, the Svelte scanner might not have hadbound_targetssupport.Let me check when
cadeb111was committed vs when2.84.0 was released: - Assistant
So there are 7 commits after the v2.84.0 release. But the issue says the false positive is on 2.84.0. Let me check if the fix (commit
cadeb111) is before or after the v2.84.0 release: - Assistant
So
cadeb111was committed on April 28, 2026, and v2.84.0 was released on a later date. Let me check: - Assistant
Let me reconsider the issue. Let me look at the broader picture - maybe the issue is about a specific scenario that's not covered. Let me check what patterns the visitor handles for binding_target_names:
- Assistant
Let me try to create a minimal reproduction of the issue to understand what's failing. Let me look at how the existing test fixture is structured and try to create a new scenario:
- Assistant
Let me look at how
propagate_accesses_through_typed_instance_bindingsworks - this is a key step in the analysis: - Assistant
OK, I've been going in circles. Let me take a completely fresh approach. Let me understand what exactly the issue is asking for by carefully comparing what Vue/Angular does for member-expression tracking versus what Svelte does. Let me look at the full
find_unused_membersanalysis function to see how member accesses are resolved: - Assistant
Let me take a completely different approach and try to reproduce the issue. Let me create a minimal test case that mimics the hister pattern and see if it fails:
- Assistant
OK let me take a completely different approach. Let me look at how bound_targets are populated and whether there's a gap. The issue says the problem is on v2.84.0. Let me carefully check what code paths produce bound_targets for Svelte:
- Assistant
Let me try a different approach. Let me try running a full analysis against a minimal project that mimics the hister pattern:
- Assistant
Now let me run the analysis on this test project:
- Assistant
Let me figure out how to run fallow with a specific directory.
- Assistant
Let me look at how to run the analysis. It seems like fallow takes the current directory as the project root.
- Assistant
Let me try running the analysis on the test project:
- Assistant
The basic case works. Only
unusedMethodis reported. Let me now test with Svelte 5$state()wrapper pattern: - Assistant
The JSON parsing failed because of the warning line. Let me fix that.
- Assistant
There it is! With
$state(new ResultState()), ALL methods including the ones used in templates are reported as unused. This is because$state(...)wraps thenewexpression, so the visitor'sconst x = new ClassName()pattern doesn't match.Let me verify this by removing the
$statewrapper: - Assistant
Without
$state(), onlyunusedMethodis reported (correct). With$state(), ALL methods are reported as unused (the bug). Now let me look at how$state()wrapping is handled and how other factory patterns liketry_extract_factory_new_classwork: - Assistant
Let me find the right file for this function.
- Assistant
I need to be in the fallow directory.
- Assistant
Let me look at the
try_extract_factory_new_classfunction: - Assistant
Now I understand! The
$state()wrapper breaks the detection because$state(new ResultState())is aCallExpressionwrapping aNewExpression, and the visitor only looks for directNewExpression. Let me test other patterns: - Assistant
letworks fine. So the issue is NOT aboutletvsconst. Let me now understand the real gap. Let me test more patterns: - Assistant
Confirmed! With
$state(new ResultState()), ALL methods are reported as unused - the FP. Now let me understand the core issue.The problem is that
$state(new ResultState())is aCallExpressionwrapping aNewExpression, and the visitor only detects directNewExpressionpatterns. Thebinding_target_namesdoesn't get populated forresultStatewhen it's wrapped in$state().But actually, re-reading the issue more carefully - the core issue might be even broader. The issue says methods called only from Svelte template member expressions are reported as unused. Let me check what happens in the case where
resultStateis NOT bound to a class at all (just passed as a prop), but methods are still called on it: - Assistant
Interesting - the prop case works! Let me test with a plain
letwithout type annotation: - Assistant
OK, so the
$state(new ResultState())case is confirmed as broken. The root cause is thatbinding_target_namesdoesn't get populated whennew ClassName()is wrapped in a function call like$state().Let me now look at the visitor code to understand the pattern and fix it.
- Assistant
Now I understand the issue clearly. The visitor handles
const x = new ClassName()but NOTlet x = $state(new ClassName()). The$state()wrapping breaks the detection. Let me now look at the existingtry_extract_factory_new_classfunction and how to extend it: - Assistant
Now I understand the issue! The problem is that
$state(new ResultState())wraps thenewexpression in a call, and the visitor doesn't detect this pattern. The binding target is not set, so the template scanner can't mapresultState.pin()toResultState.pin().The fix needs to:
- Extend the visitor to detect
let x = $state(new ClassName())or more generallylet x = call(new ClassName())patterns - Create appropriate
binding_target_namesentries for these patterns
Let me look at how the existing patterns work and implement the fix:
- Extend the visitor to detect
- Assistant
Now I need to add a pattern to detect
let x = $state(new ClassName()). Let me first understand whattry_extract_factory_new_classdoes, then add support for directNewExpressionarguments: - Assistant
Wait, let me re-examine the prop case. I need to understand why it works:
- Assistant
Hmm, the prop case actually works. Let me investigate how. Let me look at how
export let resultState: ResultStateflows through the extract/analyze pipeline more carefully: - Assistant
Good, the prop case with type annotation works correctly. So the issue is specifically about
$state()wrapping. Let me now trace through how the type annotation case works, and then understand what needs to change for$state(): - Assistant
Let me look at how typed variable declarations (like
export let resultState: ResultState) get their binding target: - Assistant
Let me find where
record_typed_bindingis called: - Assistant
So
record_typed_bindingis called for:- Class property declarations (line 1472, 1474, 1484) - handles
prop: ClassNamein class bodies - Some other context (line 1995) - let me check what this is
The prop case
export let resultState: ResultStatewould be handled by the visitor's variable declaration handling. Let me look at line 1995: - Class property declarations (line 1472, 1474, 1484) - handles
- Assistant
Now I understand the full picture. The
record_typed_bindinghandlesexport let resultState: ResultStatevia type annotations (line 1995). But$state(new ResultState())has no explicit type annotation - it relies on thenewexpression for type inference.The fix should add a pattern to detect
let x = call(new ClassName())where aNewExpressionis passed directly as an argument to a call expression. This handles$state(new ClassName())and similar patterns.Let me implement the fix:
- Assistant
Now let me implement the fix. I need to add support for
let x = $state(new ClassName())patterns. Let me first add a helper function: - Assistant
Now I need to add a new helper function to extract class names from direct
NewExpressionarguments (not wrapped in arrow functions), and then add the matching pattern in the visitor. Let me add the helper function first: - Assistant
Now let me add a helper function to detect
$state(new ClassName())style patterns: - Assistant
Now let me add a new helper function that extracts class names from direct
NewExpressionarguments: - Assistant
Let me use the edit command properly:
- Assistant
Now let me add the pattern in the visitor to use this new helper function. I need to add a case for
let x = call(new ClassName()): - Assistant
Let me verify the changes are correct:
- Assistant
Good. Now let me verify the visitor changes:
- Assistant
Let me check the visitor changes:
- Assistant
Good. Let me verify the context looks right:
- Assistant
Now let me also verify that the
Argument::NewExpressionvariant exists in the oxc AST. Let me check the Argument enum: - Assistant
Let me check if
Argument::NewExpressionexists in oxc_ast: - Assistant
Let me check the oxc AST documentation or source to see if
Argument::NewExpressionexists. - Assistant
Let me find the oxc AST source files to check the Argument enum.
- Assistant
Let me check how the
Argumentenum is defined in oxc: - Assistant
Let me look at the oxc_ast enum definition for Argument.
- Assistant
Let me look at the Argument enum definition.
- Assistant
The
Argumentenum inherits allExpressionvariants via@inherit Expression, soArgument::NewExpressionis a valid variant. Let me now build and test: - Assistant
Build succeeded! Now let me test with the
$state(new ResultState())case: - Assistant
The fix works! Now only
ResultState.unusedMethodis reported as unused, which is correct. Let me verify the existing patterns still work: - Assistant
The existing pattern still works. Let me also test with other wrapper patterns:
- Assistant
Good, the generic wrapper pattern works too. Let me also test that built-in constructors are properly excluded:
- Assistant
Good, built-in constructors are properly excluded. Now let me run the existing tests to make sure I didn't break anything:
- Assistant
All SFC parsing tests pass. Let me also run the unused_members tests:
- Assistant
All 43 unused_members tests pass. Let me run a broader set of tests to make sure nothing is broken:
- Assistant
All 523 integration tests pass! Let me also run the extract and core crate tests:
- Assistant
All 1638 extract tests pass. Let me run the core tests too:
- Assistant
All tests pass. Let me also run the full test suite to make sure nothing is broken:
- Assistant
Let me check if that test failure is pre-existing:
- Assistant
Good - the failing test is pre-existing (it fails on the original code too). Let me restore my changes:
- Assistant
Good, the test failure is pre-existing. Let me now also run clippy to make sure the code quality is good:
- Assistant
Let me fix the clippy warning:
- Assistant
Let me run clippy again to make sure the fix is correct:
- Assistant
Clippy passes. Let me run the full test suite once more to confirm:
- Assistant
All 523 tests pass. Now let me add proper tests for this fix. Let me add both a unit test and an integration test:
- Assistant
Let me add a unit test for the new
try_extract_wrapped_new_classfunction: - Assistant
Let me look at the test section to see where I should add tests:
- Assistant
Let me find existing tests related to factory new class to add adjacent tests:
- Assistant
Let me look at the test module to understand how tests are structured:
- Assistant
Instead of adding a unit test that would require constructing OXC AST nodes, let me add an integration test that tests the full pipeline. Let me add a test to the SFC parsing integration tests:
- Assistant
Let me find the svelte test area and add a test for
$state()wrapper: - Assistant
Let me look at the test to understand its structure:
- Assistant
Now I need to add a test fixture that uses
$state(new Counter()). Let me create it: - Assistant
Now let me add the integration test:
- Assistant
Now let me run the new test to make sure it passes:
- Assistant
The new test passes. Let me run all SFC parsing tests to make sure nothing is broken:
- Assistant
All 18 tests pass including the new one. Let me now check the full diff to make sure everything is clean:
- Assistant
Let me also check if there are new fixture files:
- Assistant
Good. Let me verify the new test fixture:
- Assistant
Let me verify the fixture files:
- Assistant
Now let me also add a unit test for the
try_extract_wrapped_new_classhelper. Let me check the existing unit test patterns in helpers.rs: - Assistant
Let me check the end of the test module:
- Assistant
The test module ends at the end of the file. Since
try_extract_wrapped_new_classrequires constructing OXC AST nodes, it's better to rely on the integration test. Let me run the full test suite one more time to confirm everything works: - Assistant
All tests pass. Let me run clippy one more time to ensure code quality:
- Assistant
Clippy passes. Let me run formatting check:
- Assistant
Everything passes. Let me now review the final changes:
- Assistant
Let me do a final review of all changes:
Other models, same or similar prompt
Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.
Identical first prompt
claude-sonnet-5Compare side by side →
claude-sonnet-5Compare side by side →
claude-sonnet-5Compare side by side →
claude-sonnet-5Compare side by side →
claude-sonnet-5Compare side by side →
Qwen/Qwen3.6-35B-A3BCompare side by side →
Qwen/Qwen3.6-35B-A3BCompare side by side →
Qwen/Qwen3.6-35B-A3BCompare side by side →
Qwen/Qwen3.6-27BCompare side by side →
Qwen/Qwen3.6-27BCompare side by side →
Qwen/Qwen3.6-27BCompare side by side →
Qwen/Qwen3.6-27BCompare side by side →