C
Headers, includes, structs, functions, typedefs, macros, and references.
reference · /help answers many of these topics inside the session
squeezy reads the languages below on your own machine and keeps a database of what your code declares and what refers to what. Questions about your code are answered from that database instead of by reading whole files into the prompt.
contents
For every language listed below, squeezy indexes your files into a code knowledge database: the things your project declares, and the links between them. It is built from your code on your machine, nothing is uploaded to build it, and it keeps up as you edit.
Each of these is one lookup rather than a hunt through files.
squeezy is not a compiler and does not type-check your project. It reads structure, which is why every relationship it reports carries a confidence label: an exact match is marked differently from one candidate among several, and an answer that a macro or a build flag makes uncertain says so rather than reading as fact. When completeness matters more than precision, squeezy says so too, and falls back to plain text search.
Files in any other language still work. They fall back to bounded search, targeted reads, and shell commands, and squeezy lists them as unsupported instead of reporting a lookup it never made. What follows is the full supported list, grouped so it scans.
Compiled, statically typed code, with the project layout its ecosystem uses: Cargo workspaces, Maven and Gradle projects, C# solutions, Go modules, SwiftPM modules, and Dart pubspec packages.
Headers, includes, structs, functions, typedefs, macros, and references.
Headers, namespaces, classes, templates, methods, and overload-heavy code.
Solutions, namespaces, usings, partial types, attributes, and members.
Pubspec package identity, libraries, parts, classes, mixins, extensions, and named arguments in Flutter-style projects.
Modules, packages, structs, interfaces, receivers, imports, and tests.
Packages, Maven/Gradle projects, classes, members, and inheritance.
Packages, Gradle projects, classes, objects, companions, and extensions.
Interfaces, implementations, categories, protocols, selector-named methods, properties, and #import header dependencies.
Cargo workspaces, crates, traits, impls, modules, and tests.
Packages, traits, objects, case classes, enums, and extension methods.
SwiftPM modules with enforced visibility, protocols, actors, structs, extensions, and property wrappers.
Dynamic languages and the script surfaces around them, including shell, PowerShell, Gradle and Jenkins build scripts, and Godot game scripts.
Godot scripts: class_name global types, inner classes, funcs, signals, enums, exported vars, and preload/extends resource dependencies.
Packages, imports, classes, traits, enums, and methods, plus Gradle build scripts and Jenkins pipelines with `apply from:` script dependencies.
ES modules, CommonJS, functions, classes, exports, and JSX.
Module tables, dot and colon declarations, literal require paths, and chunk-local scope.
Namespaces, Composer-style code, traits, enums, attributes, and methods.
Packages, subs, `use`/`require` module loads resolved against @INC-style paths, and method calls walked through @ISA when the invocant is known.
Scripts, script modules, manifests, dot-sourced and imported files, functions, classes, and enums.
Packages, imports, classes, functions, decorators, and inheritance.
Function bindings, globals, S4/reference/R6 class idioms, package attaches, and the source() closure that decides what a script can call.
Classes, modules, mixins, singleton methods, accessors, and require paths.
Scripts, functions, commands, and executable shell entry points.
Types, interfaces, imports, generics, classes, and TSX.
Module-first languages where what a name refers to follows imports, aliases, and open or include directives rather than the file's path.
Namespaces, requires resolved through the classpath munge, vars, protocols, records, multimethods, and .clj/.cljc/.cljs/.edn files.
Modules resolved by fully-qualified name rather than path, alias and import directives expanded at the call site, and remote versus local call scope.
Modules and their export lists, imports with qualification and hiding, data and newtype declarations, constructors, record selectors, type classes, instances, and where-bound helpers.
Compilation units as modules, functors, module types, records and variants, and open/include scope resolved in the caller's own lexical scope. Signature files are indexed as declarations in their own right, never as definitions competing with the implementation they constrain.
Markup, stylesheets, and single-file components, where a component's script block and the template that renders it are indexed together.
Pages and layouts, frontmatter TypeScript, component imports, and rendered component references.
Selectors, classes, IDs, keyframes, and stylesheet structure.
Elements, IDs, classes, tags, and document structure.
Components, script-block declarations, component imports, and template component references.
Single-file components, script-block declarations, component imports, and template component references.
The formats a repository's wiring lives in. Keys, resources, catalog objects, and messages are indexed as declarations, and the references between files resolve like any other import.
Terraform modules, resources, variables, locals, traversals, and generic HCL blocks.
Attribute sets, let bindings, inherited attributes, lambdas, and relative path imports across packages, modules, and flakes.
Packages, messages, enums, services and their rpcs, oneofs, fields, and imports resolved against include roots.
Schemas, tables, columns, views, routines, indexes, and triggers, with queries bound to the catalog objects they touch.
Mapping keys as nested declarations, anchors and aliases, and relative file references between workflows, manifests, and compose files.
Prose formats, indexed for headings, anchors, and cross-references so documentation is navigable next to the code it describes.
Section titles, anchors, inline references, and documentation structure.
Headings, sections, links, symbol references, and documentation structure.
Indexed text file roots for navigation and search.
Underline sections, Sphinx cross-reference roles, and inline literals.
Usually by file extension. Compound endings are matched as one unit, so
a .d.ts is indexed as TypeScript and a
.rst.txt as reStructuredText rather than as a plain text
file. Files with no extension at all are covered by name, so nothing
useful is skipped for lacking a suffix: Gemfile,
Rakefile, Podfile, Brewfile, and
Vagrantfile are indexed as Ruby, Jenkinsfile
as Groovy, and shell startup files such as .bashrc and
.zshrc as Shell.
Where an extension is genuinely ambiguous, squeezy asks for evidence
instead of guessing. A script with no extension is classified from a
fixed list of shebang interpreters. Endings that several ecosystems
share, such as .pl and .t, are indexed only
when the start of the file shows which language wrote them. A
.h header is decided by the C, C++, or Objective-C sources
sitting beside it. A file that stays inconclusive is left out of the
database and treated like any other unsupported file: still readable,
still searchable, but not indexed.
Every indexed file also carries a role beside its language:
implementation, test, configuration, DSL, stub, interface, and a few
more. The role is separate from the grammar, which is what lets a Ruby
Gemfile and a Ruby library file share a parser without
being treated as the same kind of input.
Coverage is not uniform, and it is checked by language family: usually
one language, sometimes a few close relatives indexed together. Where
an outside authority for a family exists, squeezy is graded against it
rather than against its own expectations: Rust against rust-analyzer,
Python against CPython's own parser, Java against javac,
C# against Roslyn, C and C++ against clang, JavaScript and TypeScript
against the TypeScript compiler, and the same arrangement for Go, Ruby,
PHP, Swift, Scala, and Dart. Every other family except the
documentation formats is held to a checked-in fixture project with its
own navigation questions and expected answers. The documentation
formats have neither, and are covered by per-format extraction tests
and doc-linking tests instead.
The benchmark page carries a measured cost
result for 15 of these languages. squeezy answers the
coverage question offline as well: squeezy help languages at a
shell, or /help languages in a session, prints every
supported language family from the registry inside the binary you
installed.
Of the rows above, four sets are one family rather than one language apiece: C with C++, JavaScript with TypeScript, Astro with Svelte and Vue, and the four documentation formats (Markdown, AsciiDoc, reStructuredText, and Plain Text) together. Everything else stands on its own.