ISSUE DESCRIPTION Unknown constant in go dependencies conflicts with Lisette's built-in…
- User
ISSUE DESCRIPTION
Unknown constant in go dependencies conflicts with Lisette's built-in Unknown type The discordgo package defines a constant named
Unknown(used for unrecognized types/events), which conflicts with Lisette's built-in Unknown type. When Lisette generates bindings for discordgo, any function signature that uses Unknown as a type parameter is misinterpreted — the compiler sees the discordgo value Unknown in a type position, causing a resolve.value_in_type_position error.Error output:
🔴 Value in type position ╭─[go:github.com_bwmarrin_discordgo.d.lis:4693:46] 4692 │ /// Logger can be used to replace the standard logging for discordgo 4693 │ pub var Logger: fn(int, int, string, VarArgs<Unknown>) -> () · ───┬─── · ╰── expected type, found value 4694 │ ╰──── help: Only a type is allowed here · code: [resolve.value_in_type_position] 🔴 Value in type position ╭─[go:github.com_bwmarrin_discordgo.d.lis:4695:21] 4694 │ 4695 │ pub var Marshal: fn(Unknown) -> Result<Slice<byte>, error> · ───┬─── · ╰── expected type, found value 4696 │ ╰──── help: Only a type is allowed here · code: [resolve.value_in_type_position] 🔴 Value in type position ╭─[go:github.com_bwmarrin_discordgo.d.lis:4697:36] 4696 │ 4697 │ pub var Unmarshal: fn(Slice<byte>, Unknown) -> Result<(), error> · ───┬─── · ╰── expected type, found value 4698 │ ╰──── help: Only a type is allowed here · code: [resolve.value_in_type_position]Root Cause
discordgodefines a constant named Unknown (e.g. Unknown Locale). Lisette also has a built-in type named Unknown used to represent opaque/untyped Go values in bindings. When the binding generator emits Unknown in a type position, the name resolves to the discordgo constant value instead of the Lisette type, triggering the error.Expected Behavior
Lisette's built-in Unknown type should take precedence in type positions, or the binding generator should qualify/disambiguate imported names that shadow built-in types.
Reproduction
Add github.com/bwmarrin/discordgo as a dependency and run lis run. The error appears immediately during binding resolution without any user-written code.
import "go:fmt" import "go:github.com/bwmarrin/discordgo" const TOKEN = "token" fn main() { let _discord = try { discordgo.New("Bot" + TOKEN)? } fmt.Println("Hello world!") }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: /lisette, current file: none) bash-$
Assistant
I'll start by exploring the repository structure to understand the codebase and find the relevant files for the binding generator.
Assistant
Now let me understand how constants are emitted, particularly how the
Unknownconstant from discordgo would be emitted.Assistant
Now I understand the flow. When a binding file uses
Unknownas a type, the resolver (lookup_qualified_name) looks in the current module first. For the discordgo binding file, the module would have a constant namedUnknown, solookup_qualified_namereturns the qualified name of the constant (the value), not the built-in type.The flow in
resolve_type_with_arity:resolve_type_namecallslookup_qualified_namewhich finds the module-localUnknownconstant.- Then
store.get_type(&qualified_name)— does this return a type for a constant? Let me check.
Actually, the issue is that
resolve_type_with_arityfinds the local constantUnknownviaresolve_type_name. But wait —resolve_type_namecallslookup_qualified_namethenstore.get_type. For a constant value, there may not be a "type" registered under that qualified name. Let me check whatstore.get_typedoes.Actually, let me reconsider. The issue is in type positions. When the binding generator emits
Unknownas a type, the resolver finds the discordgoUnknownconstant in the module's definitions. Thenclassify_non_type_namedetects it's a value (constant) and reportsvalue_in_type_position.So the fix should be in the binding generator: when emitting
Unknownas a built-in type, it should be qualified asprelude.Unknownor similar to avoid the conflict. OR the resolver should prefer the built-in/preludeUnknowntype when the local name is a value (constant) rather than a type.The issue says: "Lisette's built-in Unknown type should take precedence in type positions, or the binding generator should qualify/disambiguate imported names that shadow built-in types."
Let me think about which approach is best. The binding generator emits
Unknownin many places. The cleanest fix might be in the resolver: when resolving a type name in a type position, if the local lookup finds a non-type (value), fall back to the prelude/builtin type.Actually wait — let me re-examine
resolve_type_with_arity:if let Some((qname, ty)) = self.resolve_type_name(store, type_name) { if arity_of(&ty) == expected_arity { return Some((qname, ty)); } if !type_name.contains('.') && let Some((pname, pty)) = self.resolve_type_from_prelude(store, type_name) && arity_of(&pty) == expected_arity { return Some((pname, pty)); } return Some((qname, ty)); }So
resolve_type_namereturns Some only ifstore.get_type(&qualified_name)returns Some. For a constant namedUnknown, is there a type registered undergo:...Unknown? Constants have definitions but may also have types. Let me checkstore.get_type.Actually the key question: does
resolve_type_namereturn Some for the constantUnknown? Ifstore.get_typereturns the type of the constant (e.g., the constant's value type), then yes. Let me look atget_type.Assistant
So
get_typereturns the type of the definition. For a constant namedUnknown,definition.ty()returns the type of the constant value (e.g. some integer type). Soresolve_type_namereturns Some for the constantUnknown. Thenresolve_type_with_arityreturns it. Thenclassify_non_type_namechecks if it's a value (constant), and since it is, reportsvalue_in_type_position.Now, let me think about the fix. There are two approaches:
- In the resolver: when a type name resolves to a non-type (value/constant) in a type position, fall back to the prelude/builtin type before reporting the error.
- In the binding generator: emit
prelude.Unknowninstead ofUnknown(or some qualified form).
The issue says "Lisette's built-in Unknown type should take precedence in type positions, or the binding generator should qualify/disambiguate imported names that shadow built-in types."
Let me think about which is more general. The binding generator emits
Unknownfor opaque Go types. If a Go package has a constant namedUnknown, the binding file will have both a constantUnknownand the type usageUnknown. The cleanest general fix: in the resolver, when in a type position and the name resolves to a value (constant), but the prelude has a type with that name, prefer the prelude type.But wait — this could change behavior for user code. If a user defines a constant
Fooand also there's a prelude typeFoo... Actually prelude types are things likeUnknown,Slice,Map,Result,Option, etc. These are specific built-in types. If a user shadows one with a constant, then uses it in a type position, currently it errors. With the fix, it would resolve to the prelude type. That seems reasonable — but might be surprising. However, the issue explicitly requests this behavior.Actually, let me reconsider. Maybe the better approach is in the binding generator — qualify the built-in
Unknowntype. But the binding generator emitsUnknownin many type positions across the code. Let me look at howUnknownis emitted and whether there's a centralized place.Actually, let me reconsider the resolver approach more carefully. The issue is specifically about
Unknownshadowing. But there might be other built-in types that could be shadowed too (e.g., a Go package with a constantSlice,Map,Result, etc.).Let me look at what built-in/prelude types exist.
Assistant
Let me look at the
builtin_typeandbuiltin_qualified_nameto understand how the preludeUnknownis qualified.Assistant
Now let me look at the
convert_to_typeflow more carefully to understand where the best place to fix is. Let me look at the full convert.rs from the top.Assistant
Now I understand the full flow. The key location is
resolve_type_with_arityand theclassify_non_type_namecheck. Let me look at how the binding generator emits types to understand both possible fix locations.Assistant
Let me look at the
Annotationtype and how compound types likeSlice,Map,Resultare parsed, to understand whether they go through the sameConstructorpath.Assistant
Let me check the parser to see how
Slice<T>,Result<T>are parsed — whether compound names go throughCompoundKind::from_name.Assistant
Now let me check how
Slice<T>is resolved inconvert_to_type. SinceSliceis aCompoundKind, there must be special handling. Let me look further in convert.rs after the constructor handling.Assistant
Now I understand the flow fully. The key thing is:
For
Slice<T>,Map<K,V>, etc., these are compound types. They get resolved throughresolve_type_with_aritywhich findsprelude.Sliceetc. But these are special -Sliceis a CompoundKind, so when resolving, doesresolve_type_namefindprelude.Slice?Wait, let me re-check.
resolve_type_with_aritycallsresolve_type_namewhich callslookup_qualified_name. ForSlice, the nameSlicewould be looked up. Since the binding file doesn't defineSlicelocally (it's a Go binding),lookup_qualified_namechecks the current module first, then unprefixed imports. The prelude is imported unprefixed typically. Soprelude.Slicewould be found.But wait — for the discordgo case,
Unknownis a constant defined locally in the discordgo binding module. Solookup_qualified_namefindsgo:github.com_bwmarrin_discordgo.Unknown(the constant) first, before checking prelude imports.So the issue is in the ordering: local module definitions take precedence over prelude (unprefixed imports). For types, that's fine because a local type should shadow a prelude type. But for a local value (constant) shadowing a prelude type, we should prefer the prelude type in type positions.
So the fix should be in
resolve_type_with_arityor in theclassify_non_type_namecheck: when a name resolves to a non-type (value/constant) but the prelude has a type with that name, prefer the prelude type.Let me think about the cleanest fix. In
resolve_type_with_arity:if let Some((qname, ty)) = self.resolve_type_name(store, type_name) { if arity_of(&ty) == expected_arity { return Some((qname, ty)); } ... }resolve_type_namereturns the constant's type. Thenarity_of(&ty)for a constant value type would be 0 (not a Forall). So ifexpected_arityis 0 (which is the case forUnknownused without type args), it returns(qname, ty)directly — the constant's qualified name and type. Thenclassify_non_type_namecatches it as a value.So I need to detect this case: when the resolved name is a value (non-type) and the prelude has a type with the same name, prefer the prelude type.
But I need to be careful — this should only apply to built-in/prelude type names that the binding generator emits (
Unknown, and potentially others). Actually, the issue says "Lisette's built-in Unknown type should take precedence in type positions".But should this be general for all prelude types? If a Go package has a constant named
Sliceand the binding generator emitsSlice<Foo>somewhere... wait, no. The binding generator emitsSlice<...>for Go slices. If a Go package has a constant namedSlice, thenSlice<Foo>in a type position would resolveSliceto the local constant, andclassify_non_type_namewould report value_in_type_position. ButSlicehas type args (arity 1), soresolve_type_with_aritywith expected_arity=1:resolve_type_namereturns the constant (arity 0), which != 1, so it falls to the prelude check... actually let me re-read:if let Some((qname, ty)) = self.resolve_type_name(store, type_name) { if arity_of(&ty) == expected_arity { return Some((qname, ty)); } if !type_name.contains('.') && let Some((pname, pty)) = self.resolve_type_from_prelude(store, type_name) && arity_of(&pty) == expected_arity { return Some((pname, pty)); } return Some((qname, ty)); // <-- returns the constant even though arity mismatches }So for
Slice<Foo>(expected_arity=1), ifSliceresolves to a constant (arity 0), it tries preludeSlice(arity 1, matches), returns prelude. SoSlicewith type args would actually work via the prelude fallback! ButUnknown(expected_arity=0) matches the constant's arity (0), so it returns the constant directly without trying prelude.So the problem is specifically when the arity matches. When
Unknown(arity 0) matches a constant (arity 0), it returns the constant.So the fix: in
resolve_type_with_arity, when the local resolution returns something, check if it's actually a type (not a value/constant). If it's a value and the prelude has a type with the same name (and matching arity), prefer the prelude type.Actually, a cleaner approach: detect whether the resolved definition is a type definition vs a value. If it's a value (constant/variable/function), and there's a prelude type with the same name, prefer the prelude type.
Let me look at how to check if a qualified name is a value.
classify_non_type_namedoes this check:store.get_definition(qualified_name)and checksDefinitionBody::Value. Let me look at DefinitionBody variants.Assistant
Now let me understand how the binding generator emits the
Unknownconstant from discordgo.Assistant
So the discordgo
Unknownconstant would be emitted aspub const Unknown: SomeType = ...(a value). This is aDefinitionBody::Valuein the Lisette store.Now let me confirm by checking the const_groups - whether constants get grouped into enums. Let me look.
Assistant
So constants can be grouped into enums. If
Unknownfrom discordgo is part of a typed const group, it might be emitted as an enum variant. Let me check the discordgoUnknown— it's a Locale constant. Looking at the issue, it referenceslocales.go#L48which isUnknown Locale = 0or similar. SoUnknownis a typed constant of typeLocale. This would likely be grouped into an enumLocalewith variantUnknown.If
Unknownis an enum variant ofLocale, thenclassify_non_type_namewould returnSome(("enum variant", help))suggesting "UseLocalefor the enum type". In that case, my fix to fall back to preludeUnknownmight be wrong — the user might wantLocale. But in the binding file, theUnknownin type positions is meant to be the preludeUnknowntype (opaque Go value), NOT the Locale enum variant.So actually, falling back to prelude
UnknownIS the right thing for the binding generator's emitted code. The binding generator usesUnknownto mean the opaque type. So when the binding file has both an enum variantUnknown(from discordgo) AND usesUnknownas the opaque type in function signatures, the opaque type usage should resolve to preludeUnknown.So my fix should fall back to prelude for ALL non-type names (enum variants, functions, values) when the prelude has a matching type. This is the most general fix and handles the
Unknowncase regardless of whether it's a value or enum variant.But wait — would this break legitimate user code? Consider a user defines an enum
Colorwith variantRed, and there's no prelude typeRed. ThenRedin type position →classify_non_type_namereturns Some → no preludeRed→ no fallback → error as before. Good.Consider a user defines an enum variant named
Result(variant of some enum). Then usesResultin a type position expecting the preludeResult. Currently:classify_non_type_namereturns Some (enum variant) → error suggesting "UseEnumName". With my fix: fall back to preludeResult. Is that wrong? Hmm, if the user wroteResult<T>(arity 2) and there's an enum variantResult... ActuallyResult<T>has arity... wait, the enum variantResultresolves with arity 0. SoResult<T>has expected_arity=1... no, Result takes 2 args. Let me not overthink. The arity matching in the prelude fallback handles this:Result<T, E>has expected_arity=2. If the localResult(enum variant) has arity 0, mismatch, but currently the code already tries prelude fallback on arity mismatch. SoResult<T, E>already works via the existing prelude fallback! The only issue is arity-0 names likeUnknown.So actually, the existing code already falls back to prelude when arity mismatches. The bug is ONLY when the arity matches (arity 0 for
Unknown). My fix adds: even when arity matches, if the local resolution is a non-type name, fall back to prelude.But should this apply to enum variants too? If a Go package has an enum (typed const group) where one variant is named
Unknown, and the binding generator usesUnknown(arity 0) as the opaque type — yes, we want prelude fallback.But what if a user genuinely defines a type named
Unknown? Thenresolve_type_namereturns a type (not a value),classify_non_type_namereturns None, no fallback. Good — user-defined typeUnknownstill takes precedence.So my fix: in
resolve_type_with_arity, when local resolution succeeds but the resolved definition is a non-type name (perclassify_non_type_name), AND the prelude has a matching-arity type, prefer the prelude.Let me implement this. I'll add the check right after
resolve_type_namesucceeds.Actually, I realize I should double check: does
classify_non_type_nameget called with&self(not&mut self)? Yes, it's&self. Andresolve_type_from_preludeis&self. Good, so I can call both withinresolve_type_with_aritywhich is&mut selfbut the borrows are fine since they take&self.Wait,
resolve_type_with_arityis&mut self. Callingself.classify_non_type_name(store, ...)takes&self, that's fine. Callingself.resolve_type_from_prelude(store, ...)takes&self, fine.Let me write the fix.
Actually, let me reconsider whether to use
classify_non_type_nameor a simpler check.classify_non_type_namedoes some work to determine if it's an enum variant vs function vs value. But I just need to know "is it a non-type name". Let me check the first part ofclassify_non_type_name:let definition = store.get_definition(qualified_name)?; if !matches!(definition.body, DefinitionBody::Value { .. }) { return None; } let body = definition.ty.unwrap_forall(); if body.get_qualified_id().is_some_and(|id| id == qualified_name) { return None; }So it returns None (is a type) if:
- No definition, OR
- Definition body is not Value (it's a TypeAlias/Enum/Struct/Interface), OR
- The value's type's qualified id == the qualified name (self-referential — this is the struct-constructor case where the name IS a type)
So
classify_non_type_namereturning Some means it's genuinely a non-type name.I'll use
classify_non_type_name. If it returns Some, fall back to prelude.Let me now implement.
Assistant
Now let me implement the fix:
Assistant
Now let me verify the change compiles:
Assistant
The change compiles. Now let me write a reproduction test. First, let me understand how tests work in this repo and whether there's a way to test the binding resolution. Let me look at existing tests.
Assistant
Let me look at how the test harness works — particularly how to write a test that checks diagnostics or that something resolves. Let me look at the UI error tests and how they work, since this is about a resolve error.
Assistant
Let me look at how multi-module tests work, since this issue requires a binding module that defines
Unknownas a constant and uses it as a type.Assistant
This is complex. Let me look at how
with_go_typedefworks and how the multimodule error snapshot tests are set up. The issue involves a Go binding module that defines a constantUnknownand usesUnknownas a type. Let me look for existing tests that simulate Go bindings with constants.Assistant
Let me look at
infer_with_go_typedefsand thewith_go_typedefbuilder, and find existing tests that use Go typedefs with constants. This is the cleanest way to reproduce. Let me search for tests that useinfer_with_go_typedefs.Assistant
Now I understand the test harness. Let me write a temporary reproduction test using
infer_with_go_typedefswhere the Go typedef module defines a constantUnknownand a var that usesUnknownas a type.Assistant
Let me look at how the spec/infer tests are organized so I can add a temporary test.
Assistant
I'll create a temporary test file and register it in mod.rs to verify the fix.
Assistant
The test passes with my fix. Now let me confirm the test FAILS without my fix (to verify the reproduction is correct). Let me temporarily revert the fix.
Assistant
The stash also removed my test registration. Let me pop the stash and temporarily revert just the convert.rs fix to confirm the test fails.
Assistant
I've confirmed the reproduction. The error
Value in type positionwith coderesolve.value_in_type_positionmatches the issue exactly. Now let me restore my fix.Assistant
The fix works. Now let me think about edge cases. Let me check whether there's a way to distinguish Go binding modules from user Lisette code, to consider whether the fix should be scoped.
Assistant
is_d_lischecks if the current file is a generated.d.listypedef file (Go binding).is_lisis the negation — true for user-written Lisette code. Let me look at howis_d_lis/is_lisis used in convert.rs to understand scoping.Assistant
Let me check existing tests for "value in type position" / enum variant in type position to make sure my fix doesn't break expected error behavior.
Assistant
There are tests for "not a type" cases. Let me look at these tests, especially the prelude and local variant ones.
Assistant
Now I understand the existing tests. Let me analyze:
infer_not_a_type_unit_variant_local: usesKind.String(qualified, contains.) — my fix's!type_name.contains('.')check skips it. ✓infer_not_a_type_unit_variant_prelude: usesNone—Noneis a variant, not a prelude type, soresolve_type_from_preludereturnsNone's variant type (arity 1) which won't match arity 0 → no fallback → error remains. ✓infer_not_a_type_constructor_variant: usesSome— no prelude type namedSome→ no fallback. ✓- The function-name tests use names with no matching prelude type → no fallback. ✓
The key insight:
prelude.UnknownIS a genuine type (soclassify_non_type_namereturnsNonefor it), whileprelude.None/prelude.Someare variants. Let me run the existing UI error tests to confirm nothing breaks.Assistant
All existing "not a type" tests pass. Now let me run the broader test suites to make sure nothing else breaks. Let me run the full UI errors and spec infer tests.
Assistant
All passing. Let me also run the spec::build tests since
value_in_type_positionwas referenced there.Assistant
There are 151 failures in spec::build. I need to check whether these are pre-existing (e.g., require a Go toolchain) or caused by my change. Let me check by reverting my fix temporarily.
Assistant
The spec::build tests fail with the SAME 151 failures even WITHOUT my change (stashed). These are pre-existing failures — they require a Go toolchain. Let me verify and clean up the generated
.snap.newfiles.Assistant
Go isn't installed, confirming the spec::build failures are pre-existing (they require Go compilation). Let me verify this by looking at the build harness.
Assistant
Let me look at why the build tests actually fail by running one with output.
Assistant
The build test failures are due to Go not being installed (no gofmt → formatting differs from snapshots). This is a pre-existing environment issue, completely unrelated to my change. Let me clean up the generated snapshot files and remove my temporary test.
Assistant
Now let me run the broader test suites that don't require Go to make sure nothing breaks (emit, infer, parse, desugar, ui).
Assistant
1576 failed — mostly spec::build and spec::emit which require Go formatting. Let me confirm by checking the breakdown and comparing against the stashed (original) state. First let me see which modules failed.
Assistant
Cargo test takes a single filter. Let me run the non-Go-dependent suites individually.
Assistant
spec::sync has 3 failures. Let me check if they're pre-existing (Go-related) or caused by my change.
Assistant
The sync failures are due to "Go toolchain not installed" — pre-existing environmental issues. Let me confirm the spec::emit failures are also Go-related (they emit Go code requiring gofmt).
Assistant
These are gofmt-related (Go output formatting). Let me confirm my change doesn't affect emit snapshots by stashing and comparing one emit test.
Assistant
Confirmed: the
blocking_sendemit test fails identically WITHOUT my change — it's a gofmt formatting issue (Go not installed), pre-existing. All non-Go-dependent test suites pass. Let me clean up the.snap.newfiles generated during testing.Assistant
The working tree is clean except for my convert.rs change. Let me now test an additional edge case: when
Unknownis an enum variant (as it would be for discordgo's typedLocaleconstant), since the bindgen may group typed constants into enums.Assistant
Interesting and important findings:
- The enum variant case and struct field/param case both PASS with my fix.
- The third test reveals that user-written Lisette code cannot define a type named
Unknownat all — there's aprelude_type_shadowedguard. So my concern about masking genuine user errors is moot: users can't shadowUnknownas a type anyway.
Let me verify the
prelude_type_shadowedcheck only applies to type definitions (not constants) and only in user code, to confirm the discordgo constant itself is allowed.Assistant
The
prelude_type_shadowedcheck only flags TYPE definitions (struct/enum/alias/interface), not value definitions (const/var). So discordgo'sUnknownconstant is allowed, and only the type-position usage needed fixing. My fix is correct: it falls back to prelude only when the local name is a VALUE (constant/variant/function), and a genuine local TYPE still wins.Let me test whether a Go binding can define a genuine TYPE named
Unknown(to confirm genuine types still take precedence in bindings):Assistant
This confirms my fix handles all cases correctly:
- A genuine Go-defined TYPE
Unknown(struct) takes precedence (no fallback) ✓ - A Go-defined VALUE
Unknown(constant/enum variant) falls back to the preludeUnknowntype ✓
Now let me clean up all temporary test files.
- A genuine Go-defined TYPE
Assistant
The working tree is clean except for my fix. Let me do a final build check and run the key non-Go test suites once more to confirm everything is in order.
Assistant
All passing. Let me build the full workspace to ensure nothing else breaks, and run clippy on the semantics crate for code quality.
Assistant
Everything builds cleanly with no clippy warnings. Let me do a final review of the complete diff.
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-35B-A3BCompare side by side →
Qwen/Qwen3.6-35B-A3BCompare side by side →
Qwen/Qwen3.5-35B-A3BCompare side by side →
Qwen/Qwen3.5-35B-A3BCompare side by side →