diff --git a/CHANGELOG.md b/CHANGELOG.md
new file mode 100644
index 0000000..a47d238
--- /dev/null
+++ b/CHANGELOG.md
@@ -0,0 +1,18 @@
+# v0.2.0
+
+Adds support for Java.
+
+Breaking:
+- Normalizations have been centralized to `snippets::parser::normalize`.
+- `snippets::text::buffer` has been merged into `snippets::text`.
+- Some vestigal traits (such as `snippets::text::ConvertCRLFToLF`) have been removed.
+- Implementation-specific constants such as `NODE_KIND_COMMENT` have been made private.
+- Removed `tree-sitter` types from the API.
+
+# v0.1.3
+
+Adds support for C++.
+Adds support for C.
+
+This repository initially existed in FOSSA's [foundation-libs](https://github.com/fossas/foundation-libs/tree/master/snippets) monorepo.
+History for this library earlier than v0.1.3 can be viewed there.
diff --git a/Cargo.toml b/Cargo.toml
index 9d91b74..6c61d0b 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,9 +1,13 @@
 [package]
 name = "snippets"
-version = "0.1.3"
+version = "0.2.0"
 edition = "2021"
 description = "Extracts snippets of programming languages from files"
 
+# This is very FOSSA specific, so don't publish to crates.io.
+# Instead, just add this as a dependency using git path: `cargo add git@github.com:fossas/lib-snippets.git`.
+publish = false
+
 [features]
 default = []
 
@@ -12,28 +16,34 @@ sha2-asm = ["sha2/asm"]
 
 # Enables support for each named language.
 # For more info, see the module documentation for the language.
-lang-all = ["lang-c99-tc3", "lang-cpp-98"]
-lang-c99-tc3 = []
-lang-cpp-98 = []
+lang-all = ["lang-c99-tc3", "lang-cpp-98", "lang-java-11"]
+lang-c99-tc3 = ["tree-sitter-c"]
+lang-cpp-98 = ["tree-sitter-cpp"]
+lang-java-11 = ["tree-sitter-java"]
 
 [dependencies]
 base64 = "0.21.2"
+bstr = "1.8.0"
+colored = "2.1.0"
+delegate = "0.10.0"
 derivative = "2.2.0"
 derive_more = "0.99.17"
 fallible-iterator = { version = "0.3.0", features = ["std"] }
 flagset = "0.4.3"
 getset = "0.1.2"
 itertools = "0.11.0"
+lazy-regex = { version = "3.0.2", features = ["std"] }
+nonempty = "0.9.0"
 once_cell = "1.18.0"
-regex = "1.9.4"
 sha2 = "0.10.7"
 strum = { version = "0.25.0", features = ["derive"] }
 tap = "1.0.1"
 thiserror = "1.0.47"
 tracing = "0.1.37"
 tree-sitter = "0.20.10"
-tree-sitter-c = "0.20.6"
-tree-sitter-cpp = "0.20.3"
+tree-sitter-c = { version = "0.20.6", optional = true }
+tree-sitter-cpp = { version = "0.20.3", optional = true }
+tree-sitter-java = { version = "0.20.2", optional = true }
 tree-sitter-traversal = "0.1.2"
 typed-builder = "0.15.2"
 
@@ -42,6 +52,7 @@ tracing-subscriber = { version = "0.3.17", features = ["env-filter"] }
 snippets = { path = ".", features = ["lang-all"] }
 criterion = "0.5.1"
 pretty_assertions = "1.4.0"
+indoc = "2.0.4"
 
 [[bench]]
 name = "hashes"
diff --git a/README.md b/README.md
index 0437f44..b585fd3 100644
--- a/README.md
+++ b/README.md
@@ -19,7 +19,20 @@ Name           | Description                                          | Kind
 `lang-cpp`     | Enables support for C++ 98.                          | Language
 `sha2-asm`     | Enables hardware acceleration for SHA2               | Performance
 
-# History
+# Compatibility
 
-This repository initially existed in FOSSA's [foundation-libs](https://github.com/fossas/foundation-libs/tree/master/snippets) monorepo.
-History for this library earlier than v0.1.3 can be viewed there.
+FOSSA generally targets the latest releases of Rust, so there is no MSRV policy.
+Releases will generally use the latest Rust features.
+
+If this becomes a problem, open an issue and we can talk it out!
+
+# Developing
+
+## Release process
+
+- [Check semver compatibility](https://crates.io/crates/cargo-semver-checks) to choose the version to be released.
+  - For example, on the feature branch you can run `cargo semver-checks --baseline-rev main`.
+- Run `cargo doc --open` to validate the public API appears as you expect.
+  - Note that this will show docs for dependency crates as well; just look at the `snippets` crate.
+- Update changelog and merge the branch to `main`.
+- Release the version by tagging it. [`cargo-release`](https://crates.io/crates/cargo-release) is recommended.
diff --git a/benches/hashes.rs b/benches/hashes.rs
index b7d0f0a..5d6f7a9 100644
--- a/benches/hashes.rs
+++ b/benches/hashes.rs
@@ -1,6 +1,8 @@
+use std::ops::Deref;
+
 use criterion::{black_box, criterion_group, criterion_main, Criterion};
 use sha2::{Digest, Sha256};
-use snippets::text::ConvertCRLFToLF;
+use snippets::parser::normalize;
 
 const INPUT: &[u8] = b"Iste nam laboriosam \r\n voluptatem \n distinctio.";
 
@@ -39,7 +41,7 @@ fn hash_vec() {
 
 fn hash_transform_iter() {
     let mut hasher = Sha256::new();
-    for c in INPUT.iter().copied().convert_crlf_lf() {
+    for &c in normalize::crlf(INPUT).deref() {
         hasher.update([c]);
     }
     let digest = hasher.finalize().as_slice().to_vec();
@@ -49,7 +51,7 @@ fn hash_transform_iter() {
 
 fn hash_transform_vec() {
     let mut hasher = Sha256::new();
-    let input = INPUT.iter().copied().convert_crlf_lf().collect::<Vec<_>>();
+    let input = normalize::crlf(INPUT);
     hasher.update(&input);
     let digest = hasher.finalize().as_slice().to_vec();
 
diff --git a/src/content.rs b/src/content.rs
new file mode 100644
index 0000000..9478745
--- /dev/null
+++ b/src/content.rs
@@ -0,0 +1,57 @@
+//! Specialized types for dealing with content provided to this library,
+//! or reading content into this library.
+
+use std::{borrow::Cow, path::Path};
+
+use derivative::Derivative;
+use derive_more::Index;
+use tap::Pipe;
+
+/// Specialized type to indicate the original content provided to the extractor,
+/// distinct from a sliced section of that content.
+#[derive(Clone, PartialEq, Eq, Derivative, Index)]
+#[derivative(Debug = "transparent")]
+pub struct Content(Vec<u8>);
+
+impl Content {
+    /// Create a new instance with the provided content.
+    pub fn new(content: Vec<u8>) -> Self {
+        Self(content)
+    }
+
+    /// Read a file on disk as content.
+    pub fn from_file(path: impl AsRef<Path>) -> Result<Self, std::io::Error> {
+        std::fs::read(path).map(Self::new)
+    }
+
+    /// View the content as a plain byte slice.
+    pub fn as_bytes(&self) -> &[u8] {
+        &self.0
+    }
+}
+
+impl<U: AsRef<[u8]>> From<U> for Content {
+    fn from(value: U) -> Self {
+        value.as_ref().pipe(|v| v.to_vec()).pipe(Self)
+    }
+}
+
+/// Common functionality for any type indicating a section of bytes to extract from [`Content`].
+pub trait ByteCoordinate {
+    /// The byte offset at which the function starts.
+    fn byte_start(&self) -> usize;
+
+    /// The byte offset at which the function ends.
+    fn byte_end(&self) -> usize;
+
+    /// Extract the text representing this part from the specified content.
+    fn extract_from<'a>(&self, content: &'a Content) -> &'a [u8] {
+        &content[self.byte_start()..self.byte_end()]
+    }
+
+    /// Extract the text representing this part from the specified content as a lossy string.
+    fn extract_from_lossy<'a>(&self, content: &'a Content) -> Cow<'a, str> {
+        let content = self.extract_from(content);
+        String::from_utf8_lossy(content)
+    }
+}
diff --git a/src/debugging.rs b/src/debugging.rs
index 2292206..b7b587b 100644
--- a/src/debugging.rs
+++ b/src/debugging.rs
@@ -1,5 +1,11 @@
 //! Provides debugging helpers to snippet extractors.
 
+use tap::{Pipe, TapOptional};
+use tracing::trace;
+use tree_sitter::Node;
+
+use crate::impl_prelude::*;
+
 /// Conversion trait for types that can be represented with [`EscapedText`].
 pub trait ToDisplayEscaped {
     fn display_escaped(&self) -> EscapedText;
@@ -25,3 +31,61 @@ impl<'a> std::fmt::Display for EscapedText<'a> {
         Ok(())
     }
 }
+
+pub(crate) fn inspect_node(node: &Node<'_>, content: &[u8]) {
+    let location = node.byte_range().pipe(SnippetLocation::from);
+    if node.is_error() {
+        let start = node.start_position();
+        let end = node.end_position();
+        trace!(
+            %location,
+            content = %location.extract_from(content).display_escaped(),
+            kind = %"syntax_error",
+            line_start = start.row,
+            line_end = end.row,
+            col_start = start.column,
+            col_end = end.column,
+        );
+    } else {
+        trace!(
+            %location,
+            content = %location.extract_from(content).display_escaped(),
+            kind = %node.kind(),
+        );
+    }
+}
+
+/// Convenience implementation for inspecting [`Node`] values
+/// in an iterator as they are iterated.
+pub trait NodeInspector<'a, I> {
+    /// Inspect each [`Node`] as it is iterated,
+    /// tracing the node content and shape.
+    fn inspect_nodes(self, content: &'a [u8]) -> InspectedNodes<'a, I>;
+}
+
+#[derive(Debug)]
+pub struct InspectedNodes<'a, I> {
+    content: &'a [u8],
+    iter: I,
+}
+
+impl<'a, 'b, I: Iterator<Item = Node<'b>>> NodeInspector<'a, I> for I {
+    /// Inspect each [`Node`] as it is iterated,
+    /// tracing the node content and shape.
+    fn inspect_nodes(self, content: &'a [u8]) -> InspectedNodes<'a, I> {
+        InspectedNodes {
+            content,
+            iter: self,
+        }
+    }
+}
+
+impl<'a, 'b, I: Iterator<Item = Node<'b>>> Iterator for InspectedNodes<'a, I> {
+    type Item = Node<'b>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.iter
+            .next()
+            .tap_some(|node| inspect_node(node, self.content))
+    }
+}
diff --git a/src/ext.rs b/src/ext.rs
new file mode 100644
index 0000000..cf369f2
--- /dev/null
+++ b/src/ext.rs
@@ -0,0 +1,3 @@
+//! Extensions for types.
+
+pub mod vec;
diff --git a/src/ext/vec.rs b/src/ext/vec.rs
new file mode 100644
index 0000000..cd6e646
--- /dev/null
+++ b/src/ext/vec.rs
@@ -0,0 +1,94 @@
+//! Extensions to [`Vec`] or Vec-like types.
+
+use nonempty::{nonempty, NonEmpty};
+
+/// Extends [`Vec`] to make it usable in a more functional style.
+pub trait FunctionalVec<T> {
+    /// Push the new element into self, returning the modified form.
+    fn pushed(self, new: T) -> Self;
+
+    /// Extend self with the provided [`IntoIterator`], returning the modified form.
+    fn extended(self, new: impl IntoIterator<Item = T>) -> Self;
+
+    /// Reverse self, returning the modified form.
+    fn reversed(self) -> Self;
+
+    /// Prepend self with the provided item.
+    fn prepended(self, new: T) -> Self;
+}
+
+impl<T> FunctionalVec<T> for Vec<T> {
+    fn pushed(mut self, new: T) -> Self {
+        self.push(new);
+        self
+    }
+
+    fn extended(mut self, new: impl IntoIterator<Item = T>) -> Self {
+        self.extend(new);
+        self
+    }
+
+    fn reversed(mut self) -> Self {
+        self.reverse();
+        self
+    }
+
+    fn prepended(self, new: T) -> Self {
+        vec![new].extended(self)
+    }
+}
+
+impl<T> FunctionalVec<T> for NonEmpty<T> {
+    fn pushed(mut self, new: T) -> Self {
+        self.push(new);
+        self
+    }
+
+    fn extended(mut self, new: impl IntoIterator<Item = T>) -> Self {
+        self.extend(new);
+        self
+    }
+
+    fn reversed(self) -> Self {
+        let mut tail = self.tail;
+        let old_head = self.head;
+
+        if let Some(head) = tail.pop() {
+            NonEmpty::new(head).extended(tail.reversed().pushed(old_head))
+        } else {
+            NonEmpty::new(old_head).extended(tail)
+        }
+    }
+
+    fn prepended(self, new: T) -> Self {
+        nonempty![new].extended(self)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use nonempty::nonempty;
+    use pretty_assertions::assert_eq;
+
+    use super::*;
+
+    #[test]
+    fn vec() {
+        let start = Vec::new;
+        assert_eq!(Vec::<i32>::new(), start().reversed());
+        assert_eq!(vec![1], start().pushed(1));
+        assert_eq!(vec![1, 2], start().pushed(1).pushed(2));
+        assert_eq!(vec![1, 2], start().extended([1, 2]));
+        assert_eq!(vec![2, 1], start().extended([1, 2]).reversed());
+    }
+
+    #[test]
+    fn nonempty() {
+        let start = || nonempty![1];
+        assert_eq!(nonempty![1], start());
+        assert_eq!(nonempty![1], start().reversed());
+        assert_eq!(nonempty![1, 2], start().pushed(2));
+        assert_eq!(nonempty![1, 2, 3], start().extended([2, 3]));
+        assert_eq!(nonempty![3, 2, 1], start().extended([2, 3]).reversed());
+    }
+}
diff --git a/src/language.rs b/src/language.rs
index 6608f57..2412719 100644
--- a/src/language.rs
+++ b/src/language.rs
@@ -9,9 +9,5 @@ pub mod c99_tc3;
 #[cfg(feature = "lang-cpp-98")]
 pub mod cpp_98;
 
-pub use normalize_code::*;
-pub use normalize_comments::*;
-
-mod normalize_code;
-mod normalize_comments;
-mod snippet_context;
+#[cfg(feature = "lang-java-11")]
+pub mod java_11;
diff --git a/src/language/c99_tc3.rs b/src/language/c99_tc3.rs
index 9d8e985..3c63bcd 100644
--- a/src/language/c99_tc3.rs
+++ b/src/language/c99_tc3.rs
@@ -35,15 +35,11 @@ use tracing::{debug, warn};
 use tree_sitter::Node;
 use tree_sitter_traversal::{traverse, traverse_tree, Order};
 
-use crate::debugging::ToDisplayEscaped;
-use crate::text::normalize_space;
-use crate::tree_sitter_consts::{NODE_KIND_FUNC_DEF, NODE_KIND_OPEN_BRACE};
+use crate::content::Content;
+use crate::debugging::{inspect_node, ToDisplayEscaped};
+use crate::parser::{normalize, NODE_KIND_FUNC_DEF, NODE_KIND_OPEN_BRACE};
 use crate::{impl_language, impl_prelude::*};
 
-use super::normalize_code::normalize_code;
-use super::normalize_comments::normalize_comments;
-use super::snippet_context::SnippetContext;
-
 /// This module implements support for C99 TC3.
 ///
 /// Review module documentation for more details.
@@ -63,16 +59,21 @@ pub struct Extractor;
 // If you make changes to this extractor, consider if they should also be made to the cpp_98 extractor
 // or if the functionality makes sense to be shared.
 impl SnippetExtractor for Extractor {
-    type Language = Language;
-
-    #[tracing::instrument(skip_all, fields(kinds = %opts.kinds(), transforms = %opts.transforms(), content_len = content.as_ref().len()))]
-    fn extract(
-        opts: &SnippetOptions,
-        content: impl AsRef<[u8]>,
-    ) -> Result<Vec<Snippet<Self::Language>>, ExtractorError> {
+    type Options = SnippetOptions;
+    type Output = Vec<Snippet<Language>>;
+
+    #[tracing::instrument(
+        skip_all,
+        fields(
+            kinds = %opts.kinds(),
+            methods = %opts.methods(),
+            content_len = content.as_bytes().len(),
+        )
+    )]
+    fn extract(opts: &Self::Options, content: &Content) -> Result<Self::Output, Error> {
         let mut parser = init_parser()?;
 
-        let content = content.as_ref();
+        let content = content.as_bytes();
         let Some(tree) = parser.parse(content, None) else {
             warn!("provided content did not parse to a tree");
             return Vec::new().pipe(Ok);
@@ -109,7 +110,7 @@ fn extract<L>(
     meta: SnippetMetadata,
     node: Node<'_>,
     content: &[u8],
-) -> Option<Result<Snippet<L>, ExtractorError>> {
+) -> Option<Result<Snippet<L>, Error>> {
     match target {
         SnippetTarget::Function => extract_function(meta, node, content),
     }
@@ -120,7 +121,7 @@ fn extract_function<L>(
     meta: SnippetMetadata,
     node: Node<'_>,
     content: &[u8],
-) -> Option<Result<Snippet<L>, ExtractorError>> {
+) -> Option<Result<Snippet<L>, Error>> {
     // The raw content here is just extracted for debugging.
     let raw = meta.location().extract_from(content);
     debug!(raw = %raw.display_escaped());
@@ -255,9 +256,9 @@ fn extract_text<'a>(method: SnippetMethod, context: &'a SnippetContext) -> Cow<'
 #[tracing::instrument(skip_all)]
 fn transform<'a>(transform: SnippetTransform, context: &'a SnippetContext) -> Cow<'a, [u8]> {
     match transform {
-        SnippetTransform::Code => normalize_code(context),
-        SnippetTransform::Comment => normalize_comments(context).into(),
-        SnippetTransform::Space => normalize_space(context.content()),
+        SnippetTransform::Code => normalize::code(context),
+        SnippetTransform::Comment => normalize::comments(context).into(),
+        SnippetTransform::Space => normalize::space(context.content()),
     }
 }
 
@@ -272,34 +273,12 @@ fn matches_target(target: SnippetTarget, node: Node<'_>) -> bool {
     }
 }
 
-#[tracing::instrument(skip_all)]
-fn inspect_node(node: &Node<'_>, content: &[u8]) {
-    let location = node.byte_range().pipe(SnippetLocation::from);
-    if node.is_error() {
-        let start = node.start_position();
-        let end = node.end_position();
-        warn!(
-            %location,
-            content = %location.extract_from(content).display_escaped(),
-            kind = %"syntax_error",
-            line_start = start.row,
-            line_end = end.row,
-            col_start = start.column,
-            col_end = end.column,
-        );
-    } else {
-        debug!(
-            %location,
-            content = %location.extract_from(content).display_escaped(),
-            kind = %node.kind(),
-        );
-    }
-}
-
 #[tracing::instrument]
-fn init_parser() -> Result<tree_sitter::Parser, ExtractorError> {
+pub(crate) fn init_parser() -> Result<tree_sitter::Parser, Error> {
     let mut parser = tree_sitter::Parser::new();
-    parser.set_language(tree_sitter_c::language())?;
+    parser
+        .set_language(tree_sitter_c::language())
+        .map_err(Error::configure)?;
     Ok(parser)
 }
 
diff --git a/src/language/cpp_98.rs b/src/language/cpp_98.rs
index 53ea890..d9c1289 100644
--- a/src/language/cpp_98.rs
+++ b/src/language/cpp_98.rs
@@ -42,15 +42,11 @@ use tracing::{debug, warn};
 use tree_sitter::Node;
 use tree_sitter_traversal::{traverse, traverse_tree, Order};
 
-use crate::debugging::ToDisplayEscaped;
-use crate::text::normalize_space;
-use crate::tree_sitter_consts::{NODE_KIND_FUNC_DEF, NODE_KIND_OPEN_BRACE};
+use crate::content::Content;
+use crate::debugging::{inspect_node, ToDisplayEscaped};
+use crate::parser::{normalize, NODE_KIND_FUNC_DEF, NODE_KIND_OPEN_BRACE};
 use crate::{impl_language, impl_prelude::*};
 
-use super::normalize_code::normalize_code;
-use super::normalize_comments::normalize_comments;
-use super::snippet_context::SnippetContext;
-
 /// This module implements support for CPP 98.
 ///
 /// Review module documentation for more details.
@@ -71,15 +67,21 @@ pub struct Extractor;
 // If you make changes to this extractor, consider if they should also be made to the c99_tc3 extractor
 // or if the functionality makes sense to be shared.
 impl SnippetExtractor for Extractor {
-    type Language = Language;
-
-    fn extract(
-        opts: &SnippetOptions,
-        content: impl AsRef<[u8]>,
-    ) -> Result<Vec<Snippet<Self::Language>>, ExtractorError> {
+    type Options = SnippetOptions;
+    type Output = Vec<Snippet<Language>>;
+
+    #[tracing::instrument(
+        skip_all,
+        fields(
+            kinds = %opts.kinds(),
+            methods = %opts.methods(),
+            content_len = content.as_bytes().len(),
+        )
+    )]
+    fn extract(opts: &Self::Options, content: &Content) -> Result<Self::Output, Error> {
         let mut parser = init_parser()?;
 
-        let content = content.as_ref();
+        let content = content.as_bytes();
         let Some(tree) = parser.parse(content, None) else {
             warn!("provided content did not parse to a tree");
             return Vec::new().pipe(Ok);
@@ -116,7 +118,7 @@ fn extract<L>(
     meta: SnippetMetadata,
     node: Node<'_>,
     content: &[u8],
-) -> Option<Result<Snippet<L>, ExtractorError>> {
+) -> Option<Result<Snippet<L>, Error>> {
     match target {
         SnippetTarget::Function => extract_function(meta, node, content),
     }
@@ -127,7 +129,7 @@ fn extract_function<L>(
     meta: SnippetMetadata,
     node: Node<'_>,
     content: &[u8],
-) -> Option<Result<Snippet<L>, ExtractorError>> {
+) -> Option<Result<Snippet<L>, Error>> {
     // The raw content here is just extracted for debugging.
     let raw = meta.location().extract_from(content);
     debug!(raw = %raw.display_escaped());
@@ -262,9 +264,9 @@ fn extract_text<'a>(method: SnippetMethod, context: &'a SnippetContext) -> Cow<'
 #[tracing::instrument(skip_all)]
 fn transform<'a>(transform: SnippetTransform, context: &'a SnippetContext) -> Cow<'a, [u8]> {
     match transform {
-        SnippetTransform::Code => normalize_code(context),
-        SnippetTransform::Comment => normalize_comments(context).into(),
-        SnippetTransform::Space => normalize_space(context.content()),
+        SnippetTransform::Code => normalize::code(context),
+        SnippetTransform::Comment => normalize::comments(context).into(),
+        SnippetTransform::Space => normalize::space(context.content()),
     }
 }
 
@@ -279,34 +281,12 @@ fn matches_target(target: SnippetTarget, node: Node<'_>) -> bool {
     }
 }
 
-#[tracing::instrument(skip_all)]
-fn inspect_node(node: &Node<'_>, content: &[u8]) {
-    let location = node.byte_range().pipe(SnippetLocation::from);
-    if node.is_error() {
-        let start = node.start_position();
-        let end = node.end_position();
-        warn!(
-            %location,
-            content = %location.extract_from(content).display_escaped(),
-            kind = %"syntax_error",
-            line_start = start.row,
-            line_end = end.row,
-            col_start = start.column,
-            col_end = end.column,
-        );
-    } else {
-        debug!(
-            %location,
-            content = %location.extract_from(content).display_escaped(),
-            kind = %node.kind(),
-        );
-    }
-}
-
 #[tracing::instrument]
-fn init_parser() -> Result<tree_sitter::Parser, ExtractorError> {
+pub(crate) fn init_parser() -> Result<tree_sitter::Parser, Error> {
     let mut parser = tree_sitter::Parser::new();
-    parser.set_language(tree_sitter_cpp::language())?;
+    parser
+        .set_language(tree_sitter_cpp::language())
+        .map_err(Error::configure)?;
     Ok(parser)
 }
 
@@ -323,6 +303,7 @@ impl<'a> FunctionParts<'a> {
     /// As a performance optimization, if the metadata only asks for the signature,
     /// body nodes are not stored. They are still traversed, in case treesitter
     /// iterates over nodes out of order.
+    #[tracing::instrument(skip_all, fields(meta))]
     fn from(meta: SnippetMetadata, node: Node<'a>, content: &'a [u8]) -> Self {
         let nodes = traverse(node.walk(), Order::Pre).inspect(|node| inspect_node(node, content));
 
diff --git a/src/language/java_11.rs b/src/language/java_11.rs
new file mode 100644
index 0000000..87eee13
--- /dev/null
+++ b/src/language/java_11.rs
@@ -0,0 +1,310 @@
+//! Implements an [`Extractor`] for the Java programming language.
+//!
+//! # Version
+//!
+//! This is based on the grammar available at https://github.com/tree-sitter/tree-sitter-java.
+//! It's not 100% clear which version of Java the grammar supports,
+//! but some of the contents of the codebase imply that it supports Java 11.
+//!
+//! That being said, this extractor should generally support newer syntax,
+//! so long as the new syntax doesn't prevent parsing functions out of the source code.
+//!
+//! [`Extractor`]: crate::Extractor
+
+use tap::{Pipe, Tap};
+use tracing::{debug, warn};
+use tree_sitter_traversal::{traverse_tree, Order};
+
+use crate::{
+    content::Content,
+    debugging::{inspect_node, NodeInspector, ToDisplayEscaped},
+    impl_language,
+    impl_prelude::*,
+    parser::{
+        java, stack::Stack, Argument, Arguments, Label, Parameter, Parameters, Scope, Visibility,
+        NODE_KIND_CONSTRUCTOR_DECL, NODE_KIND_METHOD_DECL,
+    },
+};
+
+/// This module implements support for Java 11.
+///
+/// Review module documentation for more details.
+#[derive(Copy, Clone)]
+pub struct Language;
+
+impl SnippetLanguage for Language {
+    const NAME: &'static str = "java_11";
+    const STRATEGY: LanguageStrategy = LanguageStrategy::Static;
+}
+
+impl_language!(Language);
+
+/// An empty struct used when no options are accepted.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct EmptyOptions;
+
+/// Extracts standard snippets from source code.
+///
+/// All targets extracted are extracted with the equivalent of
+/// [`SnippetTarget::Function`], [`SnippetKind::Full`], and [`SnippetMethod::Raw`].
+pub struct Extractor;
+
+impl SnippetExtractor for Extractor {
+    type Options = EmptyOptions;
+    type Output = Vec<Snippet<Language>>;
+
+    #[tracing::instrument(skip_all, fields(content_len = content.as_bytes().len()))]
+    fn extract(_: &Self::Options, content: &Content) -> Result<Self::Output, Error> {
+        let mut parser = parser()?;
+
+        let content = content.as_bytes();
+        let Some(tree) = parser.parse(content, None) else {
+            warn!("provided content did not parse to a tree");
+            return Vec::new().pipe(Ok);
+        };
+
+        traverse_tree(&tree, Order::Pre)
+            // Report syntax errors as warnings.
+            // Always write a debugging line for each node, regardless of the kind of node.
+            .inspect(|node| inspect_node(node, content))
+            // Nodes that are not "named" are syntax,
+            // which this function currently ignores.
+            //
+            // Reference:
+            // https://tree-sitter.github.io/tree-sitter/using-parsers#named-vs-anonymous-nodes
+            .filter(|node| node.is_named())
+            // Filter to the kinds this extractor cares about.
+            .filter(|node| {
+                let kind = node.kind();
+                kind == NODE_KIND_METHOD_DECL || kind == NODE_KIND_CONSTRUCTOR_DECL
+            })
+            // Hand each node off to be processed into a possible snippet,
+            // based on the provided options.
+            .map(|node| {
+                node.byte_range()
+                    .pipe(SnippetLocation::from)
+                    .pipe(|loc| extract_function(loc, node, content))
+            })
+            // Then just collect all the produced snippets and done!
+            // `From<Iterator> for Result<T, E>` stops iteration on the first error as well.
+            .collect()
+    }
+}
+
+#[tracing::instrument(skip_all)]
+fn extract_function<L>(
+    loc: SnippetLocation,
+    node: tree_sitter::Node<'_>,
+    content: &[u8],
+) -> Result<Snippet<L>, Error> {
+    // The raw content here is just extracted for debugging.
+    let raw = loc.extract_from(content);
+    debug!(raw = %raw.display_escaped());
+
+    // The actual context, the part the snippet scanner cares about, is built here.
+    //
+    // In the future, this will likely be extended to support other kinds of context,
+    // similar to the C/C++ languages.
+    let context = SnippetContext::new(node, loc, content);
+    debug!(context = %context.content().display_escaped());
+
+    // Transformations would normally be applied on text extracted from the context.
+    // However, this language doesn't support transforms yet, so no transforms are performed.
+    let text = context.content();
+    debug!(text = %text.display_escaped());
+
+    // The more exact location generated above overwrites the overall node location,
+    // otherwise users would just always see the whole node.
+    //
+    // For now, this also asserts their kind and method.
+    // This is done so that the output shape is compatible with other snippets.
+    let meta = SnippetMetadata::new(SnippetKind::Full, SnippetMethod::Raw, context.location());
+    Snippet::from(meta, text)
+        .tap(|snippet| debug!(fingerprint = %snippet.fingerprint()))
+        .pipe(Ok)
+}
+
+/// Extracts function call graphs from source code.
+pub struct CallGraphExtractor;
+
+impl SnippetExtractor for CallGraphExtractor {
+    type Options = EmptyOptions;
+    type Output = Stack<Node>;
+
+    #[tracing::instrument(skip_all)]
+    fn extract(_: &Self::Options, content: &Content) -> Result<Self::Output, Error> {
+        let mut parser = parser()?;
+
+        let content = content.as_bytes();
+        let Some(tree) = parser.parse(content, None) else {
+            warn!("provided content did not parse to a tree");
+            return Stack::default().pipe(Ok);
+        };
+
+        // As the content is parsed, it can't be collapsed
+        // into something simple like a lookup table;
+        // this is because Java is a scoped language so the same
+        // name may indicate multiple symbol paths at different scopes.
+        //
+        // Instead, this parser builds a stack of symbols,
+        // performing a naive search of the entire stack (from front to back)
+        // to resolve names into their fully qualified symbols.
+        //
+        // Symbols that are not found in the stack are assumed syntactically correct,
+        // and that they are declared in a different file in the same package.
+        //
+        // Note that this is not a generalized parser for Java;
+        // it is specific to _methods_ and therefore only stores
+        // symbols that are required for resolving methods to their
+        // declarations. As a concrete example, this parser ignores enums,
+        // because they are not relevant for looking up methods.
+        let mut stack = Stack::default();
+
+        // Build the stack. Reporting the call graph is a two-phase operation
+        // becuase each given symbol may depend on things that come
+        // later in the file.
+        for node in traverse_tree(&tree, Order::Pre).inspect_nodes(content) {
+            if let Some(scope) = java::scope(node, content) {
+                match scope {
+                    Scope::Enter(location) => stack.enter(location),
+                    Scope::Exit(location) => stack.exit(location),
+                }
+                continue;
+            }
+
+            if let Some(symbol) = java::symbol(node, content) {
+                stack.push(symbol);
+                continue;
+            }
+        }
+
+        Ok(stack)
+    }
+}
+
+/// A node in the file syntax tree.
+#[derive(Clone, Eq, PartialEq, Debug, Hash, strum::Display)]
+#[strum(serialize_all = "snake_case")]
+#[non_exhaustive]
+pub enum Node {
+    /// Represents a package name.
+    Package { name: Label },
+
+    /// Represents an import.
+    Import { name: Label },
+
+    /// Represents a class name.
+    Class { name: Label, visibility: Visibility },
+
+    /// Represents a constructor of a class.
+    Constructor {
+        name: Label,
+        params: Parameters,
+        visibility: Visibility,
+    },
+
+    /// Represents a method on a class.
+    Method {
+        name: Label,
+        params: Parameters,
+        visibility: Visibility,
+    },
+
+    /// Represents a method invocation.
+    ///
+    /// `target` is the name of the symbol on which the method was invoked;
+    /// this likely needs to be resolved in the current scope
+    /// (for example it is likely a variable or an import).
+    Invocation {
+        name: Label,
+        args: Arguments,
+        target: Label,
+    },
+
+    /// Represents a variable.
+    Variable {
+        name: Label,
+        type_name: Label,
+        visibility: Visibility,
+    },
+}
+
+impl Node {
+    pub fn new_package(name: impl Into<Label>) -> Self {
+        Self::Package { name: name.into() }
+    }
+
+    pub fn new_import(name: impl Into<Label>) -> Self {
+        Self::Import { name: name.into() }
+    }
+
+    pub fn new_class(visibility: Visibility, name: impl Into<Label>) -> Self {
+        Self::Class {
+            name: name.into(),
+            visibility,
+        }
+    }
+
+    pub fn new_constructor(
+        visibility: Visibility,
+        name: impl Into<Label>,
+        params: impl IntoIterator<Item = Parameter>,
+    ) -> Self {
+        Self::Constructor {
+            name: name.into(),
+            params: Parameters::new(params),
+            visibility,
+        }
+    }
+
+    pub fn new_variable(
+        visibility: Visibility,
+        name: impl Into<Label>,
+        type_name: impl Into<Label>,
+    ) -> Self {
+        Self::Variable {
+            name: name.into(),
+            type_name: type_name.into(),
+            visibility,
+        }
+    }
+
+    pub fn new_method(
+        visibility: Visibility,
+        name: impl Into<Label>,
+        params: impl IntoIterator<Item = Parameter>,
+    ) -> Self {
+        Self::Method {
+            name: name.into(),
+            params: Parameters::new(params),
+            visibility,
+        }
+    }
+
+    pub fn new_invocation(
+        name: impl Into<Label>,
+        target: impl Into<Label>,
+        args: impl IntoIterator<Item = Argument>,
+    ) -> Self {
+        Self::Invocation {
+            name: name.into(),
+            target: target.into(),
+            args: Arguments::new(args),
+        }
+    }
+}
+
+impl From<&Node> for Node {
+    fn from(value: &Node) -> Self {
+        value.clone()
+    }
+}
+
+#[tracing::instrument]
+pub(crate) fn parser() -> Result<tree_sitter::Parser, Error> {
+    let mut parser = tree_sitter::Parser::new();
+    parser
+        .set_language(tree_sitter_java::language())
+        .map_err(Error::configure)?;
+    Ok(parser)
+}
diff --git a/src/language/normalize_code.rs b/src/language/normalize_code.rs
deleted file mode 100644
index 688a567..0000000
--- a/src/language/normalize_code.rs
+++ /dev/null
@@ -1,60 +0,0 @@
-use std::borrow::Cow;
-
-use tap::Pipe;
-
-use super::{normalize_comments, snippet_context::SnippetContext};
-use crate::text::normalize_space;
-
-/// Perform both comment and code normalization.
-///
-/// Uses [`super::normalize_comments`] and [`crate::text::normalize_space`].
-#[tracing::instrument(skip_all)]
-pub fn normalize_code<'a>(context: &'a SnippetContext) -> Cow<'a, [u8]> {
-    normalize_comments(context)
-        .pipe_borrow(normalize_space)
-        .pipe(Vec::from)
-        .into()
-}
-
-#[cfg(test)]
-mod tests {
-
-    use crate::impl_prelude::SnippetLocation;
-    use crate::language::snippet_context::SnippetContext;
-    use tree_sitter_traversal::{traverse_tree, Order};
-
-    #[cfg(feature = "lang-c99-tc3")]
-    #[test]
-    fn normalizes_code() {
-        //! Technically, `[normalize_code]` has applications beyond C.
-        //! This is meant to be a very basic test and uses C.
-        //! Language specific tests should also be done against this as they are implemented.
-        let text = r#"int main() {
-  printf("Hello, world!"); // comment
-  /* A longer comment */
-}"#
-        .as_bytes();
-        let expected_text = r#"int main() { printf("Hello, world!"); }"#;
-
-        let mut parser = tree_sitter::Parser::new();
-        parser
-            .set_language(tree_sitter_c::language())
-            .expect("Could not set language");
-
-        let tree = parser.parse(text, None).expect("Couldn't parse test text");
-        let context = SnippetContext::from_nodes(
-            traverse_tree(&tree, Order::Pre),
-            SnippetLocation::builder()
-                .byte_offset(0)
-                .byte_len(text.len())
-                .build(),
-            text,
-        );
-
-        let out_text = super::normalize_code(&context);
-        assert_eq!(
-            std::str::from_utf8(out_text.as_ref()).expect("Could not parse out text"),
-            expected_text
-        );
-    }
-}
diff --git a/src/language/normalize_comments.rs b/src/language/normalize_comments.rs
deleted file mode 100644
index d8939c5..0000000
--- a/src/language/normalize_comments.rs
+++ /dev/null
@@ -1,64 +0,0 @@
-use crate::tree_sitter_consts::NODE_KIND_COMMENT;
-
-use super::snippet_context::SnippetContext;
-
-/// Remove all comment node text from the given content.
-/// In general, this function should work in any language for which treesitter produces nodes whose `kind` equals [`NODE_KIND_COMMENT`].
-///
-/// Because tree sitter parsers can define their own node types
-/// it's possible a comment node may have a kind not equal to [`NODE_KIND_COMMENT`].
-/// Extractors that use this function should test each language-specific comment syntax at least once.
-#[tracing::instrument(skip_all)]
-pub fn normalize_comments<'a>(context: &'a SnippetContext) -> Vec<u8> {
-    let comment_nodes = context
-        .nodes()
-        .iter()
-        .filter(|n| n.kind() == NODE_KIND_COMMENT);
-    context.content_around(comment_nodes)
-}
-
-#[cfg(test)]
-mod tests {
-
-    use crate::impl_prelude::SnippetLocation;
-    use crate::language::snippet_context::SnippetContext;
-    use tree_sitter_traversal::{traverse_tree, Order};
-
-    #[cfg(feature = "lang-c99-tc3")]
-    #[test]
-    fn normalizes_comments() {
-        //! Technically, `[normalize_comments]` has applications beyond C.
-        //! This is meant to be a very basic test and uses C.
-        //! Language specific tests should also be done against this during full fingerprinting.
-        let text = r#"int main() {
-  printf("Hello, world!"); // comment
-  /* A longer comment */
-}"#
-        .as_bytes();
-        let expected_text = r#"int main() {
-  printf("Hello, world!"); 
-  
-}"#;
-
-        let mut parser = tree_sitter::Parser::new();
-        parser
-            .set_language(tree_sitter_c::language())
-            .expect("Could not set language");
-
-        let tree = parser.parse(text, None).expect("Couldn't parse test text");
-        let context = SnippetContext::from_nodes(
-            traverse_tree(&tree, Order::Pre),
-            SnippetLocation::builder()
-                .byte_offset(0)
-                .byte_len(text.len())
-                .build(),
-            text,
-        );
-
-        let out_text = super::normalize_comments(&context);
-        assert_eq!(
-            std::str::from_utf8(out_text.as_ref()).expect("Could not parse out text"),
-            expected_text
-        );
-    }
-}
diff --git a/src/language/snippet_context.rs b/src/language/snippet_context.rs
deleted file mode 100644
index 7e7468c..0000000
--- a/src/language/snippet_context.rs
+++ /dev/null
@@ -1,67 +0,0 @@
-use crate::impl_prelude::SnippetLocation;
-use getset::{CopyGetters, Getters};
-use tree_sitter::Node;
-use tree_sitter_traversal::{traverse, Order};
-
-/// This structure represents a view into a larger piece of parsed text.
-/// For snippet scanning, we generally look at just parts of a larger piece of text for each snippet.
-#[derive(Debug, PartialEq, Getters, CopyGetters)]
-pub struct SnippetContext<'a> {
-    /// The location (in `content`) of this snippet.
-    #[getset(get_copy = "pub")]
-    location: SnippetLocation,
-
-    /// Parsed nodes representing the snippet.
-    #[getset(get = "pub")]
-    nodes: Vec<Node<'a>>,
-
-    /// The full text in which this snippet resides.
-    content: &'a [u8],
-}
-
-impl<'a> SnippetContext<'a> {
-    /// Make a new instance from a parent node and its location within the original parsed text.
-    ///
-    /// Ensure that the content provided is the same as the content used to extract the parent node;
-    /// byte offsets must line up for operations on this type to make sense.
-    pub fn new(parent: Node<'a>, location: SnippetLocation, content: &'a [u8]) -> Self {
-        Self::from_nodes(traverse(parent.walk(), Order::Pre), location, content)
-    }
-
-    /// Make a new instance from a set of nodes and their location within the original parsed text.
-    ///
-    /// Ensure that the content provided is the same as the content used to extract the nodes;
-    /// byte offsets must line up for operations on this type to make sense.
-    pub fn from_nodes(
-        nodes: impl IntoIterator<Item = Node<'a>>,
-        location: SnippetLocation,
-        content: &'a [u8],
-    ) -> Self {
-        SnippetContext {
-            nodes: nodes.into_iter().collect(),
-            location,
-            content,
-        }
-    }
-
-    /// Extract the part of the content indicated by the location.
-    pub fn content(&self) -> &[u8] {
-        self.location.extract_from(self.content)
-    }
-
-    /// Get content from the snippet which is not in ranges covered by the provided nodes.
-    pub fn content_around(&self, nodes: impl Iterator<Item = &'a Node<'a>>) -> Vec<u8> {
-        let mut slices = Vec::new();
-        let mut start_byte = self.location.start_byte();
-
-        for node in nodes {
-            let node_start_byte = node.start_byte();
-            slices.push(&self.content[start_byte..node_start_byte]);
-            start_byte = node.end_byte();
-        }
-
-        // `Location::end_byte` is inclusive.
-        slices.push(&self.content[start_byte..=self.location.end_byte()]);
-        slices.concat()
-    }
-}
diff --git a/src/lib.rs b/src/lib.rs
index 4259f1c..fea6266 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,13 +1,9 @@
 #![doc = include_str!("../README.md")]
 #![deny(clippy::invalid_regex)]
 
-use std::{
-    borrow::Cow,
-    marker::PhantomData,
-    ops::{Range, RangeInclusive},
-    str::Utf8Error,
-};
+use std::{collections::HashSet, marker::PhantomData, path::Path, str::Utf8Error};
 
+use content::Content;
 use derivative::Derivative;
 use derive_more::{Constructor, Deref, Index};
 pub use fallible_iterator::FallibleIterator;
@@ -15,31 +11,37 @@ use flagset::{flags, FlagSet};
 use getset::{CopyGetters, Getters};
 use itertools::Itertools;
 use once_cell::sync::OnceCell;
+use parser::bytes::Location;
 use strum::{Display, EnumIter};
-use tap::Conv;
+use tap::{Conv, Pipe};
 use thiserror::Error;
+use tree_sitter::Node;
+use tree_sitter_traversal::{traverse, Order};
 use typed_builder::TypedBuilder;
 
+pub mod content;
 pub mod debugging;
+pub(crate) mod ext;
 pub mod language;
+pub mod parser;
 pub mod text;
-mod tree_sitter_consts;
 
 /// Convenience import for all types that
 /// an implementation of [`Extractor`] would likely need.
 ///
 /// Some commonly-named types are renamed to reduce the likelihood of collisions
-/// when imported via this prelude: e.g. [`Error`] becomes [`ExtractorError`].
+/// when imported via this prelude: e.g. [`Error`] becomes `ExtractorError`.
 ///
 /// [`Extractor`]: crate::Extractor
-/// [`Error`]: crate::Error
+/// [`Error`]: enum@crate::Error
 pub mod impl_prelude {
+    pub use super::parser::bytes::Location as SnippetLocation;
     pub use super::{
-        Error as ExtractorError, Extractor as SnippetExtractor, Kind as SnippetKind,
+        Context as SnippetContext, Error, Extractor as SnippetExtractor, Kind as SnippetKind,
         Kinds as SnippetKinds, Language as SnippetLanguage, LanguageError,
-        Location as SnippetLocation, Metadata as SnippetMetadata, Method as SnippetMethod,
-        Options as SnippetOptions, Snippet, Strategy as LanguageStrategy, Target as SnippetTarget,
-        Transform as SnippetTransform, Transforms as SnippetTransforms,
+        Metadata as SnippetMetadata, Method as SnippetMethod, Options as SnippetOptions, Snippet,
+        Strategy as LanguageStrategy, Target as SnippetTarget, Transform as SnippetTransform,
+        Transforms as SnippetTransforms,
     };
 }
 
@@ -52,11 +54,14 @@ pub enum Error {
 
     #[error("read input as utf8")]
     DecodeUTF8(#[from] Utf8Error),
+
+    #[error("read file content")]
+    ReadFile(#[source] std::io::Error),
 }
 
-impl From<tree_sitter::LanguageError> for Error {
-    fn from(err: tree_sitter::LanguageError) -> Self {
-        LanguageError(err).into()
+impl Error {
+    fn configure(err: tree_sitter::LanguageError) -> Self {
+        format!("{err}").pipe(LanguageError).into()
     }
 }
 
@@ -64,32 +69,33 @@ impl From<tree_sitter::LanguageError> for Error {
 // Note: Implementing it this way allows us to keep `tree_sitter` out of the public API.
 //       More details: https://docs.rs/thiserror/latest/thiserror/
 #[derive(Debug, Error)]
-#[error(transparent)]
-pub struct LanguageError(#[from] tree_sitter::LanguageError);
+#[error("language: {0}")]
+pub struct LanguageError(String);
 
-/// An implementation of [`Extractor`] enables snippets to be extracted
+/// An implementation of [`Extractor`] enables output to be extracted
 /// from a given unit of source code (typically a file).
 pub trait Extractor {
-    /// The source language supported by the implementation.
-    type Language: Language;
+    /// The options accepted by the extractor.
+    type Options;
 
-    /// Reads the provided unit of source code for snippets, according to the provided options.
-    ///
-    /// # Reader
-    ///
-    /// The [`Read`] instance provided to `source` may be partially or fully consumed during this process.
-    ///
-    /// If the reader was previously read (partially or fully, by example via [`Extractor::support`]),
-    /// it almost definitely needs to be reset to the initial point before using this method.
-    fn extract(
-        opts: &Options,
-        content: impl AsRef<[u8]>,
-    ) -> Result<Vec<Snippet<Self::Language>>, Error>;
+    /// The output of the extractor.
+    type Output;
+
+    /// Reads the provided unit of source code for output, according to the provided options.
+    fn extract(opts: &Self::Options, content: &Content) -> Result<Self::Output, Error>;
+
+    /// Reads the provided file for output, according to the provided options.
+    fn extract_file(opts: &Self::Options, path: &Path) -> Result<Self::Output, Error> {
+        let content = Content::from_file(path).map_err(Error::ReadFile)?;
+        Self::extract(opts, &content)
+    }
 }
 
-/// Options for extracting snippets.
+/// Default options for extracting snippets.
 /// Options are constructed via the `Options::builder` method.
 ///
+/// Note that different extractors can provide unique option types.
+///
 /// # Best effort
 ///
 /// Constructed combinations of options may not make sense.
@@ -131,7 +137,7 @@ pub trait Extractor {
 ///
 /// assert_eq!(options.targets(), Targets::full());
 /// assert_eq!(options.kinds(), Kinds::full());
-/// assert_eq!(options.transforms(), Transforms::full());
+/// assert_eq!(options.methods(), &Methods::full());
 /// ```
 ///
 /// Restricting the kinds of snippet extracted:
@@ -147,31 +153,29 @@ pub trait Extractor {
 /// ```
 /// # use snippets::*;
 /// let options = Options::new(Target::Function, Kinds::full(), Transform::Comment);
-/// assert!(options.transforms().contains(Transform::Comment));
-/// assert!(!options.transforms().contains(Transform::Space));
+/// assert!(options.methods().contains_transform(Transform::Comment));
+/// assert!(!options.methods().contains_transform(Transform::Space));
 /// ```
 ///
 /// Only use [`Method::Raw`]:
 /// ```
 /// # use snippets::*;
-/// let options = Options::new(Target::Function, Kinds::full(), Transforms::none());
-/// assert!(options.transforms().is_empty());
+/// let options = Options::new(Target::Function, Kinds::full(), Methods::raw());
+/// assert!(options.methods().contains(Method::Raw));
 /// ```
-#[derive(Debug, Clone, Copy, PartialEq, Eq, CopyGetters)]
-#[getset(get_copy = "pub")]
+#[derive(Debug, Clone, PartialEq, Eq, Getters, CopyGetters)]
 pub struct Options {
     /// The target units of source code to extract as snippets.
+    #[getset(get_copy = "pub")]
     targets: Targets,
 
     /// The kinds of snippet to extract.
+    #[getset(get_copy = "pub")]
     kinds: Kinds,
 
     /// The normalizations used to extract this snippet.
-    transforms: Transforms,
-
-    /// Include the `raw` method.
-    /// Recommended for general use; disabling is mainly intended for tests.
-    include_raw: bool,
+    #[getset(get = "pub")]
+    methods: Methods,
 }
 
 impl Options {
@@ -179,38 +183,26 @@ impl Options {
     pub fn new(
         targets: impl Into<Targets>,
         kinds: impl Into<Kinds>,
-        transforms: impl Into<Transforms>,
+        methods: impl Into<Methods>,
     ) -> Self {
         Self {
             targets: targets.conv::<Targets>().default_if_empty(),
             kinds: kinds.conv::<Kinds>().default_if_empty(),
-            transforms: transforms.into(),
-            include_raw: true,
+            methods: methods.into(),
         }
     }
 
-    /// Disable generating [`Method::Raw`] snippets.
-    pub fn disable_raw(self) -> Self {
-        Self {
-            include_raw: false,
-            ..self
-        }
+    /// Ensure that [`Method::Raw`] is disabled in the options.
+    /// Ideally, just don't pass this method in the options in the first place.
+    pub fn disable_raw(mut self) -> Self {
+        self.methods.0.remove(&Method::Raw);
+        self
     }
 
     /// Report the cartesian product of the configured [`Kind`]s of snippets to extract
     /// with configured [`Method`]s to apply.
     pub fn cartesian_product(&self) -> impl Iterator<Item = (Target, Kind, Method)> {
-        let include_raw = self.include_raw;
-        itertools::iproduct!(
-            self.targets.iter(),
-            self.kinds.iter(),
-            Method::iter(self.transforms).filter(move |method| {
-                match method {
-                    Method::Raw => include_raw,
-                    _ => true,
-                }
-            })
-        )
+        itertools::iproduct!(self.targets.iter(), self.kinds.iter(), self.methods.iter())
     }
 }
 
@@ -219,8 +211,7 @@ impl Default for Options {
         Self {
             targets: Targets::full(),
             kinds: Kinds::full(),
-            transforms: Transforms::full(),
-            include_raw: true,
+            methods: Methods::full(),
         }
     }
 }
@@ -464,177 +455,6 @@ impl std::fmt::Display for Metadata {
     }
 }
 
-/// The location in the unit of source code from which the snippet was extracted.
-///
-/// After opening the file (so a hypothetical reader is at byte offset `0`),
-/// the reader then skips a number of bytes equal to `byte_offset`,
-/// then reads a number of bytes equal to `byte_len`.
-/// The bytes that were read compose the entire snippet.
-///
-/// For example, given the file:
-/// ```not_rust
-/// #include <stdio.h>
-///
-/// int main() {
-///   printf("hello world\n");
-///   return 0;
-/// }
-/// ```
-///
-/// In the representation the computer sees, it looks like this (using `⏎` to represent a newline):
-/// ```not_rust
-/// #include <stdio.h>⏎⏎int main() {⏎  printf("hello world\n");⏎  return 0;⏎}⏎
-/// ^^^^                ^        ^
-/// 0123...             20 <-9-> 29
-/// ```
-///
-/// The [`Location`] below represents the `int main()` snippet in that example:
-/// ```
-/// # // ⏎ is a multi-byte symbol, so use an empty space for demonstration instead.
-/// # let example = "#include <stdio.h>  int main() {}";
-/// # use snippets::*;
-/// let location = Location::builder().byte_offset(20).byte_len(10).build();
-///
-/// let range = location.as_range();
-/// let snippet = &example.as_bytes()[range];
-///
-/// let got = std::str::from_utf8(snippet)?;
-/// assert_eq!(got, "int main()");
-/// # Ok::<(), std::str::Utf8Error>(())
-/// ```
-//
-// Note: we use a `TypedBuilder` instead of a `Constructor` here because this way we can accept
-// a standard `usize` for each argument while still making it very clear in-code
-// which argument is which.
-//
-// Basically, the intent is to straddle the line between newtype convenience and newtype safety.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord, CopyGetters, TypedBuilder)]
-#[getset(get_copy = "pub")]
-pub struct Location {
-    /// The byte offset at which the snippet began.
-    #[builder(setter(transform = |input: usize| ByteOffset(input)))]
-    byte_offset: ByteOffset,
-
-    /// The number of bytes to read for the snippet from the file.
-    #[builder(setter(transform = |input: usize| ByteLen(input)))]
-    byte_len: ByteLen,
-}
-
-impl std::fmt::Display for Location {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}..={}", self.start_byte(), self.end_byte())
-    }
-}
-
-impl Location {
-    /// Read a [`Location`] as a range, intended to be used to index a buffer of bytes.
-    pub fn as_range(&self) -> std::ops::Range<usize> {
-        let start = self.byte_offset.0;
-        let len = self.byte_len.0;
-        let end = start + len;
-        start..end
-    }
-
-    /// The index of the first byte indicated for the provided location.
-    pub fn start_byte(&self) -> usize {
-        self.as_range().start
-    }
-
-    /// The index of the last byte indicated for the provided location.
-    pub fn end_byte(&self) -> usize {
-        let end = self.as_range().end;
-        if end == 0 {
-            0
-        } else {
-            end - 1 // as_range is not inclusive, so the last byte _to be read_ is less one.
-        }
-    }
-
-    /// Extract the bytes indicated by a [`Location`] from a buffer.
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// # use snippets::*;
-    /// let example = "#include <stdio.h>  int main() {}";
-    /// let location = Location::builder().byte_offset(20).byte_len(10).build();
-    ///
-    /// let got = location.extract_from(example.as_bytes());
-    /// assert_eq!(got, b"int main()");
-    /// ```
-    pub fn extract_from<'a>(&self, buf: &'a [u8]) -> &'a [u8] {
-        &buf[self.as_range()]
-    }
-
-    /// Extract the bytes indicated by a [`Location`] from a buffer,
-    /// into a lossily converted [`String`].
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// # use snippets::*;
-    /// let example = "#include <stdio.h>  int main() {}";
-    /// let location = Location::builder().byte_offset(20).byte_len(10).build();
-    ///
-    /// let got = location.extract_from_lossy(example.as_bytes());
-    /// assert_eq!(got, "int main()");
-    /// ```
-    pub fn extract_from_lossy<'a>(&self, buf: &'a [u8]) -> Cow<'a, str> {
-        let bytes = self.extract_from(buf);
-        String::from_utf8_lossy(bytes)
-    }
-}
-
-impl From<Range<usize>> for Location {
-    fn from(value: Range<usize>) -> Self {
-        let start = value.start;
-        let end = value.end;
-        Self {
-            byte_offset: ByteOffset(start),
-            byte_len: ByteLen(end - start),
-        }
-    }
-}
-
-impl From<RangeInclusive<usize>> for Location {
-    fn from(value: RangeInclusive<usize>) -> Self {
-        let start = *value.start();
-        let end = *value.end() + 1;
-        Self {
-            byte_offset: ByteOffset(start),
-            byte_len: ByteLen(end - start),
-        }
-    }
-}
-
-/// The byte offset at which the snippet began.
-///
-/// Zero-based, meaning that if the snippet begins on the first byte of the file,
-/// this offset is `0`.
-///
-/// Think of the offset as
-/// "the number of bytes to skip from the start of the file to when this snippet begins".
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord, derive_more::Display)]
-pub struct ByteOffset(usize);
-
-impl ByteOffset {
-    /// View the offset as a usize.
-    pub fn as_usize(self) -> usize {
-        self.0
-    }
-}
-
-/// The number of bytes to read for the snippet from the file.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord, derive_more::Display)]
-pub struct ByteLen(usize);
-
-impl ByteLen {
-    /// View the length as a usize.
-    pub fn as_usize(self) -> usize {
-        self.0
-    }
-}
-
 flags! {
     /// The kind of item this snippet represents.
     ///
@@ -796,6 +616,99 @@ impl std::fmt::Display for Kinds {
     }
 }
 
+/// Methods used to extract snippets.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Methods(HashSet<Method>);
+
+impl Methods {
+    /// Convenience constructor for all methods.
+    pub fn full() -> Self {
+        Transforms::full().pipe(Self::raw_and)
+    }
+
+    /// Construct a set of methods which only contains the `Raw` method.
+    pub fn raw() -> Self {
+        HashSet::from_iter([Method::Raw]).pipe(Self)
+    }
+
+    /// Construct a set of methods including raw and the provided transforms.
+    pub fn raw_and(transforms: Transforms) -> Self {
+        Method::iter(transforms).collect::<HashSet<_>>().pipe(Self)
+    }
+
+    /// Construct an empty set of methods.
+    pub fn empty() -> Self {
+        HashSet::new().pipe(Self)
+    }
+
+    /// Add a method to the set.
+    pub fn insert(&mut self, method: Method) {
+        self.0.insert(method);
+    }
+
+    /// Iterate over methods in the set.
+    pub fn iter(&self) -> impl Iterator<Item = Method> + Clone {
+        self.0.iter().copied().collect_vec().into_iter()
+    }
+
+    /// Report whether a method is contained in the set.
+    pub fn contains(&self, test: Method) -> bool {
+        self.0.contains(&test)
+    }
+
+    /// Report whether a transform is contained in the set.
+    pub fn contains_transform(&self, test: Transform) -> bool {
+        for method in &self.0 {
+            let Method::Normalized(transform) = method else {
+                continue;
+            };
+            if *transform == test {
+                return true;
+            }
+        }
+        false
+    }
+}
+
+impl From<Option<Transforms>> for Methods {
+    fn from(value: Option<Transforms>) -> Self {
+        match value {
+            Some(transforms) => Self::from(transforms),
+            None => Self::raw(),
+        }
+    }
+}
+
+impl From<Option<Transform>> for Methods {
+    fn from(value: Option<Transform>) -> Self {
+        Transforms::from(value).pipe(Self::from)
+    }
+}
+
+impl From<Transform> for Methods {
+    fn from(value: Transform) -> Self {
+        Transforms::from(value).pipe(Self::from)
+    }
+}
+
+impl From<Transforms> for Methods {
+    fn from(value: Transforms) -> Self {
+        Self::raw_and(value)
+    }
+}
+
+impl std::fmt::Display for Methods {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let methods = self
+            .iter()
+            .sorted_unstable()
+            .map(|t| t.to_string())
+            .collect_vec()
+            .join(",");
+        write!(f, "{methods}")
+    }
+}
+
 /// The method used to extract this snippet.
 ///
 /// # Specificity order
@@ -813,7 +726,7 @@ impl std::fmt::Display for Kinds {
 /// # let arbitrary = Transform::Space;
 /// assert!(Method::Raw > Method::Normalized(arbitrary));
 /// ```
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 #[non_exhaustive]
 pub enum Method {
     /// Generated from the text with the specified normalizations applied.
@@ -1218,6 +1131,69 @@ trait DefaultIfEmpty: Default {
     }
 }
 
+/// This structure represents a view into a larger piece of parsed text.
+/// For snippet scanning, we generally look at just parts of a larger piece of text for each snippet.
+#[derive(Debug, PartialEq, Getters, CopyGetters)]
+pub struct Context<'a> {
+    /// The location (in `content`) of this snippet.
+    #[getset(get_copy = "pub")]
+    location: Location,
+
+    /// Parsed nodes representing the snippet.
+    #[getset(get = "pub")]
+    nodes: Vec<Node<'a>>,
+
+    /// The full text in which this snippet resides.
+    content: &'a [u8],
+}
+
+impl<'a> Context<'a> {
+    /// Make a new instance from a parent node and its location within the original parsed text.
+    ///
+    /// Ensure that the content provided is the same as the content used to extract the parent node;
+    /// byte offsets must line up for operations on this type to make sense.
+    pub fn new(parent: Node<'a>, location: Location, content: &'a [u8]) -> Self {
+        Self::from_nodes(traverse(parent.walk(), Order::Pre), location, content)
+    }
+
+    /// Make a new instance from a set of nodes and their location within the original parsed text.
+    ///
+    /// Ensure that the content provided is the same as the content used to extract the nodes;
+    /// byte offsets must line up for operations on this type to make sense.
+    pub fn from_nodes(
+        nodes: impl IntoIterator<Item = Node<'a>>,
+        location: Location,
+        content: &'a [u8],
+    ) -> Self {
+        Context {
+            nodes: nodes.into_iter().collect(),
+            location,
+            content,
+        }
+    }
+
+    /// Extract the part of the content indicated by the location.
+    pub fn content(&self) -> &[u8] {
+        self.location.extract_from(self.content)
+    }
+
+    /// Get content from the snippet which is not in ranges covered by the provided nodes.
+    pub fn content_around(&self, nodes: impl Iterator<Item = &'a Node<'a>>) -> Vec<u8> {
+        let mut slices = Vec::new();
+        let mut start_byte = self.location.start_byte();
+
+        for node in nodes {
+            let node_start_byte = node.start_byte();
+            slices.push(&self.content[start_byte..node_start_byte]);
+            start_byte = node.end_byte();
+        }
+
+        // `Location::end_byte` is inclusive.
+        slices.push(&self.content[start_byte..=self.location.end_byte()]);
+        slices.concat()
+    }
+}
+
 #[cfg(test)]
 mod tests {
 
@@ -1279,10 +1255,7 @@ mod tests {
 
     #[test]
     fn location_round_trip() {
-        let location = Location {
-            byte_offset: ByteOffset(20),
-            byte_len: ByteLen(10),
-        };
+        let location = Location::builder().byte_offset(20).byte_len(10).build();
         let inclusive_range = 20..=29;
         let range = 20..30;
 
@@ -1293,10 +1266,7 @@ mod tests {
 
     #[test]
     fn location_bytes_round_trip() {
-        let location = Location {
-            byte_offset: ByteOffset(10),
-            byte_len: ByteLen(10),
-        };
+        let location = Location::builder().byte_offset(10).byte_len(10).build();
 
         let input = "0123456789helloworld_abcdefghijk";
         assert_eq!(location.extract_from(input.as_bytes()), b"helloworld");
@@ -1315,10 +1285,7 @@ mod tests {
     #[test]
     fn location_extract() {
         let input = "0123456789helloworld0123456789";
-        let location = Location {
-            byte_offset: ByteOffset(10),
-            byte_len: ByteLen(10),
-        };
+        let location = Location::builder().byte_offset(10).byte_len(10).build();
 
         assert_eq!(location.extract_from(input.as_bytes()), b"helloworld");
         assert_eq!(location.start_byte(), 10);
@@ -1328,10 +1295,7 @@ mod tests {
     #[test]
     fn location_extract_end() {
         let input = "0123456789helloworld";
-        let location = Location {
-            byte_offset: ByteOffset(10),
-            byte_len: ByteLen(10),
-        };
+        let location = Location::builder().byte_offset(10).byte_len(10).build();
 
         assert_eq!(location.extract_from(input.as_bytes()), b"helloworld");
     }
diff --git a/src/parser.rs b/src/parser.rs
new file mode 100644
index 0000000..659c3bc
--- /dev/null
+++ b/src/parser.rs
@@ -0,0 +1,402 @@
+//! Higher level parsers and constants on top of tree-sitter primitives.
+
+use delegate::delegate;
+use getset::{CopyGetters, Getters};
+use itertools::Itertools;
+use tap::Pipe;
+
+use self::bytes::Location;
+
+pub mod bytes;
+pub mod iter;
+pub mod normalize;
+pub mod stack;
+
+#[cfg(feature = "lang-java-11")]
+pub mod java;
+
+pub(crate) const NODE_KIND_COMMENT: &str = "comment";
+pub(crate) const NODE_KIND_FUNC_DEF: &str = "function_definition";
+pub(crate) const NODE_KIND_METHOD_DECL: &str = "method_declaration";
+pub(crate) const NODE_KIND_CONSTRUCTOR_DECL: &str = "constructor_declaration";
+pub(crate) const NODE_KIND_OPEN_BRACE: &str = "{";
+pub(crate) const NODE_KIND_CLOSE_BRACE: &str = "}";
+pub(crate) const NODE_KIND_SEMI: &str = ";";
+
+/// Equality isn't the only form of comparison.
+/// This trait expresses another form: checking whether an item satisfies a constraint.
+pub trait Constraint<T> {
+    /// Report whether `self` (the constraint) is satisfied by
+    /// `other` (the item being checked against the constraint).
+    fn satisfied_by(&self, other: T) -> bool;
+}
+
+/// Kinds of scope that can be parsed.
+#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash, strum::Display)]
+#[strum(serialize_all = "snake_case")]
+#[non_exhaustive]
+pub enum Scope {
+    /// Denotes a scope entry.
+    Enter(Location),
+
+    /// Denotes a scope exit.
+    Exit(Location),
+}
+
+impl Scope {
+    /// Create a new variant from the provided location.
+    pub fn new_enter(location: impl Into<Location>) -> Self {
+        location.into().pipe(Self::Enter)
+    }
+
+    /// Create a new variant from the provided location.
+    pub fn new_exit(location: impl Into<Location>) -> Self {
+        location.into().pipe(Self::Exit)
+    }
+}
+
+/// The label of a generic symbol.
+#[derive(Clone, Eq, PartialEq, Hash, derive_more::Display)]
+pub struct Label(String);
+
+impl Label {
+    /// Create a new instance with the provided value.
+    pub fn new(label: impl Into<String>) -> Self {
+        label.into().pipe(Self)
+    }
+}
+
+impl<S: Into<String>> From<S> for Label {
+    fn from(value: S) -> Self {
+        value.into().pipe(Self)
+    }
+}
+
+impl std::fmt::Debug for Label {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+
+/// The visibility for a symbol.
+///
+/// Note that this is not necessarily all the same visibility levels as a given language;
+/// mostly this library just cares whether a symbol is public or not.
+#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash, strum::Display)]
+#[strum(serialize_all = "snake_case")]
+#[non_exhaustive]
+pub enum Visibility {
+    /// The symbol is accessible from outside the package.
+    Public,
+
+    /// The symbol is only accessible within the package.
+    Private,
+}
+
+/// Contains multiple parameters for a specific function.
+#[derive(Clone, Eq, PartialEq, Hash, Debug, Default)]
+pub struct Parameters(Vec<Parameter>);
+
+impl Parameters {
+    /// Construct a new instance with the provided parameters.
+    pub fn new(params: impl IntoIterator<Item = Parameter>) -> Self {
+        params.into_iter().collect_vec().pipe(Self)
+    }
+
+    /// Construct a new instance from a set of arguments.
+    /// Assumes all arguments become single parameters.
+    pub fn from_args(args: impl IntoIterator<Item = Argument>) -> Self {
+        args.into_iter()
+            .map(Parameter::Single)
+            .collect_vec()
+            .pipe(Self)
+    }
+
+    delegate! {
+        to self.0 {
+            /// Test whether the set is empty.
+            pub fn is_empty(&self) -> bool;
+
+            /// Iterate through the set.
+            pub fn iter(&self) -> impl Iterator<Item = &Parameter>;
+        }
+    }
+}
+
+impl IntoIterator for Parameters {
+    type Item = Parameter;
+
+    type IntoIter = std::vec::IntoIter<Self::Item>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.0.into_iter()
+    }
+}
+
+impl<'a, I: IntoIterator<Item = &'a Argument>> Constraint<I> for Parameters {
+    /// Check whether the set of arguments satisfies the set of parameters.
+    /// This is distinct from equality.
+    ///
+    /// The key difference is that parameters are really _constraints_ on arguments:
+    /// - A single parameter is a constraint: "give me a single argument of this type".
+    /// - A variadic parameter is a looser constraint: "give me any number of arguments of this type".
+    /// - A generic parameter is even looser: "give me an argument that matches this interface".
+    ///
+    /// This method checks whether the set of arguments provided matches
+    /// the constraints imposed by the set of parameters.
+    fn satisfied_by(&self, args: I) -> bool {
+        let mut args = args.into_iter().peekable();
+        for parameter in self.0.iter() {
+            // Automatically handles variadic parameters.
+            if !parameter.satisfied_by(args.next()) {
+                return false;
+            }
+
+            // If the parameter is variadic, eagerly consume all the arguments that match it.
+            if matches!(parameter, Parameter::Variadic(_)) {
+                args.peeking_take_while(|arg| parameter.satisfied_by(*arg))
+                    .for_each(|_| {});
+            }
+        }
+
+        // Non-matching conditions early return with false.
+        true
+    }
+}
+
+/// Kinds of function parameters that can be parsed.
+///
+/// Distinct from [`Argument`] in that parameters are part of _declarations_,
+/// while arguments are part of _invocations_. The key difference is that
+/// parameters are really _constraints_ on arguments:
+///
+/// - A single parameter is a constraint: "give me a single argument of this type".
+/// - A variadic parameter is a looser constraint: "give me any number of arguments of this type".
+/// - A generic parameter is even looser: "give me an argument that matches this interface".
+///
+/// This type is meant to encapsulate this concept.
+#[derive(Clone, Eq, PartialEq, Hash, Debug)]
+#[non_exhaustive]
+pub enum Parameter {
+    /// Accepts a single argument of the specified type.
+    Single(Argument),
+
+    /// Accepts any number of arguments of the specified type.
+    Variadic(Argument),
+}
+
+impl std::fmt::Display for Parameter {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Parameter::Single(arg) => write!(f, "{arg}"),
+            Parameter::Variadic(arg) => write!(f, "{arg}..."),
+        }
+    }
+}
+
+impl Constraint<Option<&Argument>> for Parameter {
+    /// Check whether an argument satisfies this parameter.
+    ///
+    /// This is distinct from equality:
+    /// - If the constraint is any, any argument satisfies it.
+    /// - Similarly, if the argument is any, it satisfies any constraint.
+    /// - Otherwise, the constraint is only satisfied if they are equal.
+    ///
+    /// Note that variadic parameters accept _any number_ of arguments,
+    /// including zero. So if the provided argument is [`None`],
+    /// _and_ the parameter is variadic, the parameter is satisfied.
+    fn satisfied_by(&self, arg: Option<&Argument>) -> bool {
+        match (self, arg) {
+            (Parameter::Single(_), None) => false,
+            (Parameter::Single(constraint), Some(arg)) => constraint.satisfied_by(arg),
+            (Parameter::Variadic(_), None) => true,
+            (Parameter::Variadic(constraint), Some(arg)) => constraint.satisfied_by(arg),
+        }
+    }
+}
+
+impl Constraint<&Argument> for Parameter {
+    /// Check whether an argument satisfies this parameter.
+    ///
+    /// This is distinct from equality:
+    /// - If the constraint is any, any argument satisfies it.
+    /// - Similarly, if the argument is any, it satisfies any constraint.
+    /// - Otherwise, the constraint is only satisfied if they are equal.
+    ///
+    /// Since this is called with an explicitly non-zero argument,
+    /// whether this parameter is single or variadic is ignored.
+    fn satisfied_by(&self, arg: &Argument) -> bool {
+        match self {
+            Parameter::Single(constraint) => constraint.satisfied_by(arg),
+            Parameter::Variadic(constraint) => constraint.satisfied_by(arg),
+        }
+    }
+}
+
+impl IntoIterator for Parameter {
+    type Item = Parameter;
+
+    type IntoIter = std::iter::Once<Self::Item>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        std::iter::once(self)
+    }
+}
+
+/// Contains multiple arguments for a specific function.
+#[derive(Clone, Eq, PartialEq, Hash, Debug, Default)]
+pub struct Arguments(Vec<Argument>);
+
+impl Arguments {
+    /// Construct a new instance with the provided arguments.
+    pub fn new(args: impl IntoIterator<Item = Argument>) -> Self {
+        args.into_iter().collect_vec().pipe(Self)
+    }
+
+    delegate! {
+        to self.0 {
+            /// Test whether the set is empty.
+            pub fn is_empty(&self) -> bool;
+
+            /// Iterate through the set.
+            pub fn iter(&self) -> impl Iterator<Item = &Argument>;
+        }
+    }
+}
+
+impl IntoIterator for Arguments {
+    type Item = Argument;
+
+    type IntoIter = std::vec::IntoIter<Self::Item>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.0.into_iter()
+    }
+}
+
+/// Kinds of arguments that can be parsed.
+///
+/// Distinct from [`Parameter`] in that parameters are part of _declarations_,
+/// while arguments are part of _invocations_.
+#[derive(Clone, Eq, PartialEq, Hash, Debug)]
+#[non_exhaustive]
+pub enum Argument {
+    /// An argument with a specific type.
+    Typed(Label),
+
+    /// An argument of indeterminate type.
+    Any,
+}
+
+impl Constraint<&Argument> for Argument {
+    /// Treat this argument as a parameter- namely, as a constraint,
+    /// then check whether the provided argument satisfies the constraint.
+    ///
+    /// This is distinct from equality:
+    /// - If the constraint is any, any argument satisfies it.
+    /// - Similarly, if the argument is any, it satisfies any constraint.
+    /// - Otherwise, the constraint is only satisfied if they are equal.
+    fn satisfied_by(&self, arg: &Argument) -> bool {
+        match (self, arg) {
+            (Argument::Any, _) | (_, Argument::Any) => true,
+            (Argument::Typed(constraint), Argument::Typed(arg)) => constraint == arg,
+        }
+    }
+}
+
+impl Constraint<Option<&Argument>> for Argument {
+    /// Treat this argument as a parameter- namely, as a constraint,
+    /// then check whether the provided argument satisfies the constraint.
+    ///
+    /// If the argument is [`None`], it is considered to not satisfy the constraint.
+    ///
+    /// This is distinct from equality:
+    /// - If the constraint is any, any argument satisfies it.
+    /// - Similarly, if the argument is any, it satisfies any constraint.
+    /// - Otherwise, the constraint is only satisfied if they are equal.
+    fn satisfied_by(&self, arg: Option<&Argument>) -> bool {
+        arg.map(|arg| self.satisfied_by(arg)).unwrap_or(false)
+    }
+}
+
+impl std::fmt::Display for Argument {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Argument::Typed(ty) => write!(f, "{ty}"),
+            Argument::Any => write!(f, "_"),
+        }
+    }
+}
+
+impl IntoIterator for Argument {
+    type Item = Argument;
+
+    type IntoIter = std::iter::Once<Self::Item>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        std::iter::once(self)
+    }
+}
+
+/// A symbol in the source code.
+///
+/// Different languages may have additional
+/// data they track about the symbol;
+/// at its base level this is just a location in the source code.
+///
+/// Language implementations can customize the generic type
+/// to replace the included metadata as appropriate.
+#[derive(Clone, PartialEq, Eq, Hash, Getters, CopyGetters)]
+pub struct Symbol<T> {
+    /// The inner type of the symbol.
+    /// This may be specific to the language being parsed.
+    #[getset(get = "pub")]
+    inner: T,
+
+    /// The location of the symbol in source code.
+    #[getset(get_copy = "pub")]
+    location: Location,
+}
+
+impl<T> Symbol<T> {
+    /// Construct a new instance with the specified inner type and location.
+    pub fn new(inner: impl Into<T>, location: impl Into<Location>) -> Self {
+        Self {
+            inner: inner.into(),
+            location: location.into(),
+        }
+    }
+}
+
+impl<T: Clone> From<&Symbol<T>> for Symbol<T> {
+    fn from(value: &Symbol<T>) -> Self {
+        value.clone()
+    }
+}
+
+impl<T: std::fmt::Debug> std::fmt::Debug for Symbol<T> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{:?} @ {:?}", &self.inner, self.location.as_range())
+    }
+}
+
+impl<T> Symbol<T> {
+    /// The byte length of the symbol.
+    pub fn len(&self) -> usize {
+        self.location.byte_len().as_usize()
+    }
+
+    /// Whether the symbol is empty.
+    pub fn is_empty(&self) -> bool {
+        self.location.is_empty()
+    }
+}
+
+/// A [`Symbol`] that has no metadata attached to it, only a location.
+pub type UnitSymbol = Symbol<()>;
+
+impl<T: Into<Location>> From<T> for UnitSymbol {
+    fn from(value: T) -> Self {
+        Symbol::new((), value)
+    }
+}
diff --git a/src/parser/bytes.rs b/src/parser/bytes.rs
new file mode 100644
index 0000000..1a0516c
--- /dev/null
+++ b/src/parser/bytes.rs
@@ -0,0 +1,298 @@
+//! Types related to working with source code represented as bytes.
+
+use std::{
+    borrow::Cow,
+    ops::{Range, RangeInclusive},
+};
+
+use derive_more::{Add, AddAssign, Display, Sub, SubAssign};
+use getset::CopyGetters;
+use tree_sitter::Node;
+use typed_builder::TypedBuilder;
+
+/// The location in a unit of source code from which content was extracted.
+///
+/// After opening the file (so a hypothetical reader is at byte offset `0`),
+/// the reader then skips a number of bytes equal to `byte_offset`,
+/// then reads a number of bytes equal to `byte_len`.
+/// The bytes that were read compose the entire content indicated by this [`Location`].
+///
+/// For example, given the file:
+/// ```not_rust
+/// #include <stdio.h>
+///
+/// int main() {
+///   printf("hello world\n");
+///   return 0;
+/// }
+/// ```
+///
+/// In the representation the computer sees, it looks like this (using `⏎` to represent a newline):
+/// ```not_rust
+/// #include <stdio.h>⏎⏎int main() {⏎  printf("hello world\n");⏎  return 0;⏎}⏎
+/// ^^^^                ^        ^
+/// 0123...             20 <-9-> 29
+/// ```
+///
+/// The [`Location`] below represents the `int main()` snippet in that example:
+/// ```
+/// # // ⏎ is a multi-byte symbol, so use an empty space for demonstration instead.
+/// # let example = b"#include <stdio.h>  int main() {}";
+/// # use snippets::parser::bytes::*;
+/// let location = Location::builder().byte_offset(20).byte_len(10).build();
+///
+/// let range = location.as_range();
+/// let snippet = &example[range];
+///
+/// let got = std::str::from_utf8(snippet)?;
+/// assert_eq!(got, "int main()");
+/// # Ok::<(), std::str::Utf8Error>(())
+/// ```
+//
+// Note: we use a `TypedBuilder` instead of a `Constructor` here because this way we can accept
+// a standard `usize` for each argument while still making it very clear in-code
+// which argument is which.
+//
+// Basically, the intent is to straddle the line between newtype convenience and newtype safety.
+#[derive(
+    Debug, Clone, Copy, Default, PartialEq, Eq, Hash, PartialOrd, Ord, CopyGetters, TypedBuilder,
+)]
+#[getset(get_copy = "pub")]
+pub struct Location {
+    /// The byte offset at which the snippet began.
+    #[builder(setter(transform = |input: usize| ByteOffset(input)))]
+    byte_offset: ByteOffset,
+
+    /// The number of bytes to read for the snippet from the file.
+    #[builder(setter(transform = |input: usize| ByteLen(input)))]
+    byte_len: ByteLen,
+}
+
+impl std::fmt::Display for Location {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}..={}", self.start_byte(), self.end_byte())
+    }
+}
+
+impl Location {
+    /// Read a [`Location`] as a range, intended to be used to index a buffer of bytes.
+    pub fn as_range(&self) -> std::ops::Range<usize> {
+        let start = self.byte_offset.0;
+        let len = self.byte_len.0;
+        let end = start + len;
+        start..end
+    }
+
+    /// The index of the first byte indicated for the provided location.
+    pub fn start_byte(&self) -> usize {
+        self.as_range().start
+    }
+
+    /// The index of the last byte indicated for the provided location.
+    pub fn end_byte(&self) -> usize {
+        let end = self.as_range().end;
+        if end == 0 {
+            0
+        } else {
+            end - 1 // as_range is not inclusive, so the last byte _to be read_ is less one.
+        }
+    }
+
+    /// Whether the location is empty.
+    pub fn is_empty(&self) -> bool {
+        self.byte_len.0 == 0
+    }
+
+    /// Extract the bytes indicated by a [`Location`] from a buffer.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use snippets::parser::bytes::*;
+    /// let example = "#include <stdio.h>  int main() {}";
+    /// let location = Location::builder().byte_offset(20).byte_len(10).build();
+    ///
+    /// let got = location.extract_from(example.as_bytes());
+    /// assert_eq!(got, b"int main()");
+    /// ```
+    pub fn extract_from<'a>(&self, buf: &'a [u8]) -> &'a [u8] {
+        &buf[self.as_range()]
+    }
+
+    /// Extract the bytes indicated by a [`Location`] from a buffer,
+    /// into a lossily converted [`String`].
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use snippets::parser::bytes::*;
+    /// let example = "#include <stdio.h>  int main() {}";
+    /// let location = Location::builder().byte_offset(20).byte_len(10).build();
+    ///
+    /// let got = location.extract_from_lossy(example.as_bytes());
+    /// assert_eq!(got, "int main()");
+    /// ```
+    pub fn extract_from_lossy<'a>(&self, buf: &'a [u8]) -> Cow<'a, str> {
+        let bytes = self.extract_from(buf);
+        String::from_utf8_lossy(bytes)
+    }
+
+    /// Report whether the provided location is enclosed within self.
+    pub fn encloses(self, other: Self) -> bool {
+        let other = other.as_range();
+        let bounds = self.as_range();
+        bounds.contains(&other.start) && bounds.contains(&other.end)
+    }
+
+    /// Report whether the provided range is enclosed within self.
+    pub fn encloses_range(self, other: &Range<usize>) -> bool {
+        let bounds = self.as_range();
+        bounds.contains(&other.start) && bounds.contains(&other.end)
+    }
+}
+
+impl From<Range<usize>> for Location {
+    fn from(value: Range<usize>) -> Self {
+        let start = value.start;
+        let end = value.end;
+        Self {
+            byte_offset: ByteOffset(start),
+            byte_len: ByteLen(end - start),
+        }
+    }
+}
+
+impl From<RangeInclusive<usize>> for Location {
+    fn from(value: RangeInclusive<usize>) -> Self {
+        let start = *value.start();
+        let end = *value.end() + 1;
+        Self {
+            byte_offset: ByteOffset(start),
+            byte_len: ByteLen(end - start),
+        }
+    }
+}
+
+impl From<Node<'_>> for Location {
+    fn from(value: Node<'_>) -> Self {
+        value.byte_range().into()
+    }
+}
+
+impl std::ops::Add for Location {
+    type Output = Self;
+
+    fn add(self, rhs: Self) -> Self::Output {
+        let start = self.start_byte().min(rhs.start_byte());
+        let end = self.end_byte().max(rhs.end_byte());
+        (start..=end).into()
+    }
+}
+
+impl std::ops::AddAssign for Location {
+    fn add_assign(&mut self, rhs: Self) {
+        *self = *self + rhs;
+    }
+}
+
+impl std::iter::Sum for Location {
+    fn sum<I: Iterator<Item = Self>>(iter: I) -> Self {
+        iter.fold(Self::default(), |a, b| a + b)
+    }
+}
+
+/// The byte offset at which the snippet began.
+///
+/// Zero-based, meaning that if the snippet begins on the first byte of the file,
+/// this offset is `0`.
+///
+/// Think of the offset as
+/// "the number of bytes to skip from the start of the file to when this snippet begins".
+#[derive(
+    Debug,
+    Clone,
+    Copy,
+    Default,
+    PartialEq,
+    Eq,
+    Hash,
+    PartialOrd,
+    Ord,
+    Display,
+    Add,
+    AddAssign,
+    Sub,
+    SubAssign,
+)]
+pub struct ByteOffset(usize);
+
+impl ByteOffset {
+    /// View the offset as a usize.
+    pub fn as_usize(self) -> usize {
+        self.0
+    }
+}
+
+/// The number of bytes to read for the snippet from the file.
+#[derive(
+    Debug,
+    Clone,
+    Copy,
+    Default,
+    PartialEq,
+    Eq,
+    Hash,
+    PartialOrd,
+    Ord,
+    Display,
+    Add,
+    AddAssign,
+    Sub,
+    SubAssign,
+)]
+pub struct ByteLen(usize);
+
+impl ByteLen {
+    /// View the length as a usize.
+    pub fn as_usize(self) -> usize {
+        self.0
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use pretty_assertions::assert_eq;
+
+    use super::*;
+
+    #[test]
+    fn location_add() {
+        let a = Location::builder().byte_offset(10).byte_len(10).build();
+        let b = Location::builder().byte_offset(20).byte_len(20).build();
+        let expected = Location::builder().byte_offset(10).byte_len(30).build();
+        assert_eq!(expected, a + b);
+
+        let example = b"some text [ highlighted text ] other text";
+        //              ^         ^           ^ ^    ^
+        //     indexes: 0        10          22 24  29
+
+        let a = Location::builder().byte_offset(10).byte_len(13).build();
+        let b = Location::builder().byte_offset(24).byte_len(6).build();
+
+        // Note that the space between them is captured.
+        assert_eq!(a.extract_from_lossy(example), "[ highlighted");
+        assert_eq!(b.extract_from_lossy(example), "text ]");
+        assert_eq!((a + b).extract_from_lossy(example), "[ highlighted text ]");
+    }
+
+    #[test]
+    fn location_add_assign() {
+        let a = Location::builder().byte_offset(10).byte_len(10).build();
+        let b = Location::builder().byte_offset(20).byte_len(20).build();
+
+        let mut c = a;
+        c += b;
+
+        assert_eq!(a + b, c);
+    }
+}
diff --git a/src/parser/iter.rs b/src/parser/iter.rs
new file mode 100644
index 0000000..b6fe071
--- /dev/null
+++ b/src/parser/iter.rs
@@ -0,0 +1,88 @@
+//! Types and helpers for treating iterators
+//! in a manner similar to combinatorial parsers.
+//!
+//! The goal isn't to replicate a full combinatorial parser;
+//! just steal some ideas from the concept.
+//!
+//! # Future work
+//!
+//! ## Wrap around an existing parser combinator
+//!
+//! Nom is adaptable to other data types than bytes,
+//! but it's kind of complicated to do, so I timeboxed it.
+//!
+//! Depending on how complicated our parser needs get,
+//! this may be worth revisiting.
+//!
+//! ## Backtracking (`alternative`)
+//!
+//! Ideal, borderline needed, for parsing true alternative arrangements:
+//! - Optional visibility modifiers (`private foo()` vs `foo()`).
+//! - Optional method targets (`this.foo()` vs `foo()`).
+//!
+//! Without backtracking, the most we can do is invert `some`
+//! to form an "alternative-like" over a single node,
+//! instead of the ideal of an alternative series of parsers.
+//!
+//! Can probably be implemented with `itertools::MultiPeek`
+//! + a wrapper around a `MultiPeek` that translates `next` to `peek`
+//! so that any parser can be turned into a backtracking parser.
+//!
+//! Then if the parse is successful, the `alternative` function
+//! just consumes items from the underlying iterator.
+//!
+//! ## Ownership of input
+//!
+//! Probably needed for backtracking.
+//!
+//! Parsers functions take ownership of the input,
+//! changing their signatures from `Parser<I, T>: Fn(I) -> Option<T>`
+//! to `Parser<I, O, T>: Fn(I) -> (O, Option<T>)`
+//! where `I` is the input and `O` is the unparsed remainder of the input.
+
+/// Describes a generic parser that works with this module.
+pub trait Parser<I, T>: Fn(I) -> Option<T> {}
+impl<I, F: Fn(I) -> Option<T>, T> Parser<I, T> for F {}
+
+/// Parses the input, searching for the first item
+/// for which the provided parser returns `Some`.
+/// Once found, returns that parsed result.
+///
+/// Items read from the iterator that fail to parse are dropped.
+pub fn some<I: Iterator, T>(input: &mut I, parser: impl Parser<I::Item, T>) -> Option<T> {
+    input.find_map(parser)
+}
+
+/// Parses while the predicate returns true, searching for the first item
+/// for which the provided parser returns `Some`.
+/// Once found, returns that parsed result.
+///
+/// The item for which the predicate
+/// returns false is consumed from the iterator.
+/// Items read from the iterator that fail to parse are dropped.
+pub fn some_while<I: Iterator, T>(
+    input: &mut I,
+    pred: impl Fn(&I::Item) -> bool,
+    parser: impl Parser<I::Item, T>,
+) -> Option<T> {
+    some(&mut input.take_while(pred), parser)
+}
+
+/// Greedily performs [`some`] until the input is done.
+/// In the case that no items were parsed, the returned vector is empty.
+pub fn many<'a, I: Iterator, T>(
+    input: &'a mut I,
+    parser: impl Parser<I::Item, T> + 'a,
+) -> impl Iterator<Item = T> + 'a {
+    std::iter::from_fn(move || some(input, &parser))
+}
+
+/// Greedily performs [`some_while`] until the input is done.
+/// In the case that no items were parsed, the returned vector is empty.
+pub fn many_while<'a, I: Iterator, T>(
+    input: &'a mut I,
+    pred: impl Fn(&I::Item) -> bool + 'a,
+    parser: impl Parser<I::Item, T> + 'a,
+) -> impl Iterator<Item = T> + 'a {
+    std::iter::from_fn(move || some_while(input, &pred, &parser))
+}
diff --git a/src/parser/java.rs b/src/parser/java.rs
new file mode 100644
index 0000000..c1f3763
--- /dev/null
+++ b/src/parser/java.rs
@@ -0,0 +1,479 @@
+//! Parsers and types for Java source code.
+//!
+//! Existing well-known combinatorial parsers (e.g. `nom`)
+//! are generally designed to parse text, and making them support
+//! more complicated structures requires a lot of work.
+//!
+//! Writing our own parsers using `nom` for Java text isn't _too_ awful,
+//! but a goal of using treesitter in the first place is to lift the responsibility
+//! for this off our shoulders (especially in regards to maintenance),
+//! so this isn't considered at this time.
+//!
+//! Instead of spending the time adapting `nom` to [`tree_sitter::Node`]s,
+//! or putting together our own fancy combinatorial parsers,
+//! this module implements hand-rolled parsers specific to
+//! specific kinds of syntax.
+//!
+//! In order to make this more convenient to implement,
+//! this module does not provide a way to choose which parser is
+//! appropriate for a given syntactical construction.
+//!
+//! As we add more implementations, we should consider providing
+//! a generalized parser abstraction to make this safer to implement.
+
+use std::borrow::Cow;
+
+use itertools::Itertools;
+use lazy_regex::regex_is_match;
+use once_cell::sync::Lazy;
+use tap::{Pipe, Tap};
+use tracing::trace;
+use tree_sitter::Node as TSNode;
+
+use crate::{
+    debugging::NodeInspector,
+    ext::vec::FunctionalVec,
+    language::java_11::Node,
+    parser::{iter::some, Argument, Parameter, Symbol, Visibility, NODE_KIND_SEMI},
+};
+
+use super::{bytes::Location, Scope, NODE_KIND_CLOSE_BRACE, NODE_KIND_OPEN_BRACE};
+
+/// A parser is any function that implements this type.
+type Parser<T> = fn(TSNode<'_>, &[u8]) -> Option<T>;
+
+/// Wrap a [`Parser`] with the provided `content` so that it fits the shape
+/// expected by [`crate::parser::iter`] (which expects a function that
+/// accepts a single argument).
+///
+/// Usage:
+/// ```ignore
+/// fn package(node: TSNode<'_>, content: &[u8]) -> Option<Symbol<Node>> {
+///     let mut ctx = traverse_statement(node, content);
+///     let name = some(&mut ctx, parser!(content, if_kind, "scoped_identifier"))?;
+///     symbol!(Node::new_package(name.inner), name.loc)
+/// }
+/// ```
+macro_rules! parser {
+    ($content:expr, $parser:expr) => {
+        |node: TSNode<'_>| $parser(node, $content)
+    };
+    ($content:expr, $parser:expr, $($args:expr),* $(,)*) => {
+        |node: TSNode<'_>| $parser(node, $content, $($args,)*)
+    };
+}
+
+/// Convenience wrapper around [`crate::parser::iter::some`] and [`parser!`].
+/// Runs the provided parser on the context, wrapping the content.
+///
+/// Usage:
+/// ```ignore
+/// fn package(node: TSNode<'_>, content: &[u8]) -> Option<Symbol<Node>> {
+///     let mut ctx = traverse_statement(node, content);
+///     let name = parse_some!(ctx => content, if_kind, "scoped_identifier")?;
+///     symbol!(Node::new_package(name.inner), name.loc)
+/// }
+/// ```
+macro_rules! parse_some {
+    ($context:ident => $($tail:tt)*) => {
+        crate::parser::iter::some(&mut $context, parser!($($tail)*))
+    };
+}
+
+/// Construct a new [`Symbol`], trace it in context, and wrap it in [`Some`].
+///
+/// Usage:
+/// ```ignore
+/// fn package(node: TSNode<'_>, content: &[u8]) -> Option<Symbol<Node>> {
+///     let mut ctx = traverse_statement(node, content);
+///     let name = parse_some!(ctx => content, if_kind, "scoped_identifier")?;
+///     symbol!(Node::new_package(name.inner), name.loc)
+/// }
+/// ```
+macro_rules! symbol {
+    ($($args:expr),* $(,)*) => {
+        Symbol::new($($args,)*).tap(|k| trace!(loc = %k.location(), kind = ?k.inner())).pipe(Some)
+    };
+}
+
+/// Ensure the node is of the specified kind,
+/// else early return from the enclosing function.
+macro_rules! ensure_node_kind {
+    ($node:expr, $kind:expr) => {{
+        if $node.kind() != $kind {
+            return None;
+        }
+    }};
+    ($node:expr, $kind_a:expr, $kind_b:expr) => {{
+        if $node.kind() != $kind_a && $node.kind() != $kind_b {
+            return None;
+        }
+    }};
+}
+
+/// A lazily initialized stack of parsers.
+type ParserStack<T> = Lazy<Vec<Parser<T>>>;
+
+/// Instantiate a [`ParserStack`] with the provided parsers.
+///
+/// Usage:
+/// ```ignore
+/// parser_stack!(T, parsers...)
+/// ```
+///
+/// Creates a static variable in the current scope with the name `PARSER_STACK`
+/// containing a stack of parsers that result in type `T`.
+///
+/// Using this and [`some`], one can form an analogue to an "alternative" parser combinator:
+/// ```ignore
+/// pub fn scope(node: TSNode<'_>, content: &[u8]) -> Option<Scope> {
+///     parser_stack!(Scope => scope_enter, scope_exit);
+///     some(&mut PARSER_STACK.iter(), |parser| parser(node, content))
+/// }
+/// ```
+macro_rules! parser_stack {
+    ($type:ty => $($args:expr),* $(,)*) => {
+        static PARSER_STACK: ParserStack<$type> = Lazy::new(|| vec![$($args,)*]);
+    };
+}
+
+/// Parse the node as a scope event.
+#[tracing::instrument(skip_all)]
+pub fn scope(node: TSNode<'_>, content: &[u8]) -> Option<Scope> {
+    parser_stack!(Scope => scope_enter, scope_exit);
+    some(&mut PARSER_STACK.iter(), |parser| parser(node, content))
+}
+
+#[tracing::instrument(skip_all)]
+fn scope_enter(node: TSNode<'_>, _: &[u8]) -> Option<Scope> {
+    ensure_node_kind!(node, NODE_KIND_OPEN_BRACE);
+    Scope::Enter(Location::from(node)).pipe(Some)
+}
+
+#[tracing::instrument(skip_all)]
+fn scope_exit(node: TSNode<'_>, _: &[u8]) -> Option<Scope> {
+    ensure_node_kind!(node, NODE_KIND_CLOSE_BRACE);
+    Scope::Exit(Location::from(node)).pipe(Some)
+}
+
+/// Attempt to parse the node as any supported symbol.
+#[tracing::instrument(skip_all)]
+pub fn symbol(node: TSNode<'_>, content: &[u8]) -> Option<Symbol<Node>> {
+    parser_stack!(
+        Symbol<Node> =>
+        invocation,
+        method,
+        field,
+        constructor,
+        class,
+        import,
+        package
+    );
+    some(&mut PARSER_STACK.iter(), |parser| parser(node, content))
+}
+
+#[tracing::instrument(skip_all)]
+fn package(node: TSNode<'_>, content: &[u8]) -> Option<Symbol<Node>> {
+    ensure_node_kind!(node, "package_declaration");
+
+    let mut ctx = traverse_statement(node, content);
+    let name = parse_some!(ctx => content, if_kind, "scoped_identifier")?;
+
+    symbol!(Node::new_package(name.inner), name.loc)
+}
+
+#[tracing::instrument(skip_all)]
+fn import(node: TSNode<'_>, content: &[u8]) -> Option<Symbol<Node>> {
+    ensure_node_kind!(node, "import_declaration");
+
+    let mut ctx = traverse_statement(node, content);
+    let name = parse_some!(ctx => content, if_kind, "scoped_identifier")?;
+    symbol!(Node::new_import(name.inner), name.loc)
+}
+
+#[tracing::instrument(skip_all)]
+fn class(node: TSNode<'_>, content: &[u8]) -> Option<Symbol<Node>> {
+    ensure_node_kind!(node, "class_declaration");
+
+    // Since visibility modifiers come first, but are optional,
+    // to parse these we need backtracking in the iterator parser.
+    // I don't have this built yet, so just assume all modifiers are public
+    // for now.
+    let visibility = Visibility::Public;
+
+    let mut ctx = traverse_while(node, content, |node| node.kind() != "class_body");
+    let name = parse_some!(ctx => content, if_kind, "identifier")?;
+
+    symbol!(Node::new_class(visibility, name.inner), name.loc,)
+}
+
+#[tracing::instrument(skip_all)]
+fn constructor(node: TSNode<'_>, content: &[u8]) -> Option<Symbol<Node>> {
+    ensure_node_kind!(node, "constructor_declaration");
+
+    // Since visibility modifiers come first, but are optional,
+    // to parse these we need backtracking in the iterator parser.
+    // I don't have this built yet, so just assume all modifiers are public
+    // for now.
+    let visibility = Visibility::Public;
+
+    let mut ctx = traverse_while(node, content, |node| node.kind() != "constructor_body");
+    let name = parse_some!(ctx => content, if_kind, "identifier")?;
+    let args = parse_some!(ctx => content, method_params)?;
+
+    symbol!(
+        Node::new_constructor(visibility, name.inner, args.inner),
+        name.loc + args.loc,
+    )
+}
+
+#[tracing::instrument(skip_all)]
+fn field(node: TSNode<'_>, content: &[u8]) -> Option<Symbol<Node>> {
+    ensure_node_kind!(node, "field_declaration");
+
+    // Since visibility modifiers come first, but are optional,
+    // to parse these we need backtracking in the iterator parser.
+    // I don't have this built yet, so just assume all modifiers are public
+    // for now.
+    let visibility = Visibility::Public;
+
+    let mut ctx = traverse_statement(node, content);
+    let type_name = parse_some!(ctx => content, if_kind, "type_identifier")?;
+    let name = parse_some!(ctx => content, if_kind, "identifier")?;
+
+    symbol!(
+        Node::new_variable(visibility, name.inner, type_name.inner),
+        type_name.loc + name.loc,
+    )
+}
+
+#[tracing::instrument(skip_all)]
+fn method(node: TSNode<'_>, content: &[u8]) -> Option<Symbol<Node>> {
+    ensure_node_kind!(node, "method_declaration");
+
+    // Since visibility modifiers come first, but are optional,
+    // to parse these we need backtracking in the iterator parser.
+    // I don't have this built yet, so just assume all modifiers are public
+    // for now.
+    let visibility = Visibility::Public;
+
+    let mut ctx = traverse_while(node, content, |node| node.kind() != "block");
+    let name = parse_some!(ctx => content, if_kind, "identifier")?;
+    let args = parse_some!(ctx => content, method_params)?;
+
+    symbol!(
+        Node::new_method(visibility, name.inner, args.inner),
+        name.loc + args.loc
+    )
+}
+
+#[tracing::instrument(skip_all)]
+fn invocation(node: TSNode<'_>, content: &[u8]) -> Option<Symbol<Node>> {
+    ensure_node_kind!(node, "method_invocation");
+
+    // Invocations are commonly in the form `target.name()`, but can also just be `name()`.
+    // In the latter case, `target` is assumed to be the current class.
+    // Invocations can also use a multipart path, like `System.out.println`.
+    let mut ctx = traverse_statement(node, content).peekable();
+    let mut target = Vec::new();
+    let name = loop {
+        let name_or_target = parse_some!(ctx => content, if_kind, "identifier")?;
+        if ctx.peek().map(|n| n.kind()) == Some(".") {
+            target.push(name_or_target);
+        } else {
+            break name_or_target;
+        }
+    };
+    let args = parse_some!(ctx => content, invocation_arguments)?;
+
+    let target = if target.is_empty() {
+        Extracted::new("this", name.loc)
+    } else {
+        target
+            .into_iter()
+            .fold(Extracted::<Vec<String>>::default(), |acc, item| {
+                if acc.is_empty() {
+                    item.map(|inner| vec![inner.to_string()])
+                } else {
+                    Extracted {
+                        inner: acc.inner.pushed(item.inner.to_string()),
+                        loc: acc.loc + item.loc,
+                    }
+                }
+            })
+            .map(|inner| inner.join("."))
+    };
+
+    symbol!(
+        Node::new_invocation(name.inner, target.inner, args.inner),
+        target.loc + name.loc + args.loc,
+    )
+}
+
+#[tracing::instrument(skip_all)]
+fn method_params<'a>(node: TSNode<'_>, content: &'a [u8]) -> Option<Extracted<Vec<Parameter>>> {
+    // treesitter provides "argument_list" when reading a method invocation,
+    // and "formal_parameters" when reading a method declaration.
+    ensure_node_kind!(node, "formal_parameters");
+
+    // In the future, we probably need to use nom to parse the declared types for method declarations.
+    // This should work because one has to declare the type of arguments in declarations.
+    // Remember complex types types exist (e.g. `Map<String, int> map`),
+    // so simply splitting on `,` or spaces isnt' good enough.
+    //
+    // For now, just handle the cases of "no arguments" or "some arguments";
+    // the latter becomes a wildcard variadic argument, so it can accept
+    // any number of any type of argument.
+    extract(node, content)
+        .map(|inner| {
+            if inner == "()" {
+                Vec::new()
+            } else {
+                vec![Parameter::Variadic(Argument::Any)]
+            }
+        })
+        .pipe(Some)
+}
+
+#[tracing::instrument(skip_all)]
+fn invocation_arguments<'a>(
+    node: TSNode<'_>,
+    content: &'a [u8],
+) -> Option<Extracted<Vec<Argument>>> {
+    ensure_node_kind!(node, "argument_list");
+
+    // In the future, we probably need to use treesitter's node kinds to determine input types.
+    // For example, `kind=string_literal` maps to `String`.
+    // This will likely need to also be able to indicate a variable that can be looked up in the stack
+    // by the caller to determine its type; this is likely at least one additional
+    // variant to the `Argument` type.
+    //
+    // For now, just turn every distinct argument into a wildcard.
+    let raw = &*extract(node, content).inner;
+
+    // Early check: if this is an empty set of parethesis, or there is only whitespace between them,
+    // just return an empty argument set.
+    if regex_is_match!(r"\(\s*\)", raw) {
+        return Extracted::new(Vec::new(), node).pipe(Some);
+    }
+
+    // Otherwise, count the comma nodes emitted by treesitter to find the argument count.
+    // Since the "no arguments" case was already checked, assume "no commas" means "one argument"
+    // (so really, "argument count" is just "comma count + 1").
+    let count = traverse(node, content)
+        .filter(|node| node.kind() == ",")
+        .count();
+    let args = std::iter::repeat(Argument::Any)
+        .take(count + 1)
+        .collect_vec();
+    Extracted::new(args, node).pipe(Some)
+}
+
+/// Since visibility modifiers come first, but are optional,
+/// to parse these we need backtracking in the iterator parser.
+///
+/// This is not built yet, so we assume all modifiers are public for now;
+/// leaving this parser unused- leaving it in the code though because
+/// it _should_ be good to go once backtracking is implemented.
+#[tracing::instrument(skip_all)]
+fn visibility(node: TSNode<'_>, content: &[u8]) -> Option<Extracted<Visibility>> {
+    ensure_node_kind!(node, "modifiers");
+    extract(node, content)
+        .map(|modifiers| {
+            if modifiers.contains("public") {
+                Visibility::Public
+            } else {
+                Visibility::Private
+            }
+        })
+        .tap(|modifiers| trace!(loc = %modifiers.loc, modifiers = %modifiers.inner))
+        .pipe(Some)
+}
+
+fn if_kind<'a>(
+    node: TSNode<'_>,
+    content: &'a [u8],
+    kind: impl AsRef<str>,
+) -> Option<Extracted<Cow<'a, str>>> {
+    ensure_node_kind!(node, kind.as_ref());
+    extract(node, content).pipe(Some)
+}
+
+/// Traverse children of a node in the syntax tree
+/// until the statement ends (a semicolon is observed).
+fn traverse_statement<'a>(node: TSNode<'a>, content: &'a [u8]) -> impl Iterator<Item = TSNode<'a>> {
+    traverse_while(node, content, |node| node.kind() != NODE_KIND_SEMI)
+}
+
+/// Traverse children of a node in the syntax tree
+/// while the predicate returns true.
+fn traverse_while<'a>(
+    node: TSNode<'a>,
+    content: &'a [u8],
+    pred: impl FnMut(&TSNode<'a>) -> bool,
+) -> impl Iterator<Item = TSNode<'a>> {
+    traverse(node, content).take_while(pred)
+}
+
+/// Traverse children of a node in the syntax tree.
+fn traverse<'a>(node: TSNode<'a>, content: &'a [u8]) -> impl Iterator<Item = TSNode<'a>> {
+    tree_sitter_traversal::traverse(node.walk(), tree_sitter_traversal::Order::Pre)
+        .inspect_nodes(content)
+}
+
+#[derive(Debug, Default)]
+struct Extracted<T> {
+    inner: T,
+    loc: Location,
+}
+
+impl<T> Extracted<T> {
+    /// Construct a new instance.
+    fn new(inner: impl Into<T>, loc: impl Into<Location>) -> Self {
+        Extracted {
+            inner: inner.into(),
+            loc: loc.into(),
+        }
+    }
+
+    /// Use the provided closure to map the interior data.
+    fn map<U>(self, map: impl FnOnce(T) -> U) -> Extracted<U> {
+        Extracted {
+            inner: map(self.inner),
+            loc: self.loc,
+        }
+    }
+
+    /// Whether the extracted item is empty.
+    fn is_empty(&self) -> bool {
+        self.loc.is_empty()
+    }
+}
+
+impl From<Extracted<Node>> for Symbol<Node> {
+    fn from(value: Extracted<Node>) -> Self {
+        Self::new(value.inner, value.loc)
+    }
+}
+
+impl std::iter::Sum for Extracted<String> {
+    fn sum<I: Iterator<Item = Self>>(iter: I) -> Self {
+        iter.fold(Extracted::<Vec<String>>::default(), |mut acc, item| {
+            if acc.is_empty() {
+                item.map(|inner| vec![inner])
+            } else {
+                acc.loc += item.loc;
+                acc.inner.push(item.inner);
+                acc
+            }
+        })
+        .map(|inner| inner.concat())
+    }
+}
+
+#[tracing::instrument(skip_all)]
+fn extract<'a>(node: TSNode<'_>, content: &'a [u8]) -> Extracted<Cow<'a, str>> {
+    let loc = node.byte_range().pipe(Location::from);
+    let text = loc.extract_from_lossy(content);
+    Extracted { inner: text, loc }
+}
diff --git a/src/parser/normalize.rs b/src/parser/normalize.rs
new file mode 100644
index 0000000..3c8c576
--- /dev/null
+++ b/src/parser/normalize.rs
@@ -0,0 +1,144 @@
+//! Normalization primitives.
+
+use std::borrow::Cow;
+
+use lazy_regex::regex_replace_all;
+use tap::Pipe;
+
+use crate::impl_prelude::*;
+
+use super::NODE_KIND_COMMENT;
+
+/// Perform both comment and code normalization.
+///
+/// Equivalent to [`comments`] followed by [`space`].
+#[tracing::instrument(skip_all)]
+pub fn code<'a>(context: &'a SnippetContext) -> Cow<'a, [u8]> {
+    comments(context)
+        .pipe_borrow(space)
+        .pipe(Vec::from)
+        .pipe(Cow::Owned)
+}
+
+/// Remove all comment node text from the given content.
+///
+/// Because tree sitter parsers can define their own node types,
+/// it's possible a comment node may have a kind that isn't expected.
+///
+/// Extractors that use this function should test each language-specific comment syntax at least once.
+#[tracing::instrument(skip_all)]
+pub fn comments<'a>(context: &'a SnippetContext) -> Vec<u8> {
+    let comment_nodes = context
+        .nodes()
+        .iter()
+        .filter(|n| n.kind() == NODE_KIND_COMMENT);
+    context.content_around(comment_nodes)
+}
+
+/// Normalize any consecutive whitespace into a single space.
+#[tracing::instrument(skip_all)]
+pub fn space(text: &[u8]) -> Cow<'_, [u8]> {
+    regex_replace_all!(r"\s+"B, text, b" ")
+}
+
+/// Normalize `\r\n` into `\n`.
+#[tracing::instrument(skip_all)]
+pub fn crlf(text: &[u8]) -> Cow<'_, [u8]> {
+    regex_replace_all!("\r\n"B, text, b"\n")
+}
+
+#[cfg(test)]
+mod tests {
+
+    use super::*;
+    use tree_sitter_traversal::{traverse_tree, Order};
+
+    #[cfg(feature = "lang-c99-tc3")]
+    #[test]
+    fn normalizes_code() {
+        //! Technically, `[normalize_code]` has applications beyond C.
+        //! This is meant to be a very basic test and uses C.
+        //! Language specific tests should also be done against this as they are implemented.
+        let text = indoc::indoc! {r#"
+            int main() {
+                printf("Hello, world!"); // comment
+                /* A longer comment */
+            }
+        "#}
+        .as_bytes();
+        let expected_text = r#"int main() { printf("Hello, world!"); } "#;
+
+        let mut parser = tree_sitter::Parser::new();
+        parser
+            .set_language(tree_sitter_c::language())
+            .expect("Could not set language");
+
+        let tree = parser.parse(text, None).expect("Couldn't parse test text");
+        let context = SnippetContext::from_nodes(
+            traverse_tree(&tree, Order::Pre),
+            SnippetLocation::builder()
+                .byte_offset(0)
+                .byte_len(text.len())
+                .build(),
+            text,
+        );
+
+        let out_text = code(&context);
+        pretty_assertions::assert_eq!(
+            std::str::from_utf8(out_text.as_ref()).expect("Could not parse out text"),
+            expected_text
+        );
+    }
+
+    #[cfg(feature = "lang-c99-tc3")]
+    #[test]
+    fn normalizes_comments() {
+        //! Technically, `[normalize_comments]` has applications beyond C.
+        //! This is meant to be a very basic test and uses C.
+        //! Language specific tests should also be done against this during full fingerprinting.
+        let text = indoc::indoc! {r#"
+            int main() {
+                printf("Hello, world!"); // comment
+                /* A longer comment */
+            }
+        "#}
+        .as_bytes();
+        let expected_text = indoc::indoc! {r#"
+            int main() {
+                printf("Hello, world!"); 
+                
+            }
+        "#};
+
+        let mut parser = tree_sitter::Parser::new();
+        parser
+            .set_language(tree_sitter_c::language())
+            .expect("Could not set language");
+
+        let tree = parser.parse(text, None).expect("Couldn't parse test text");
+        let context = SnippetContext::from_nodes(
+            traverse_tree(&tree, Order::Pre),
+            SnippetLocation::builder()
+                .byte_offset(0)
+                .byte_len(text.len())
+                .build(),
+            text,
+        );
+
+        let out_text = comments(&context);
+        pretty_assertions::assert_eq!(
+            std::str::from_utf8(out_text.as_ref()).expect("Could not parse out text"),
+            expected_text
+        );
+    }
+
+    #[test]
+    fn normalizes_crlf() {
+        let input = "foo\nbar\r\nbaz";
+        let expected = "foo\nbar\nbaz";
+        let normalized = crlf(input.as_bytes());
+        let normalized = String::from_utf8_lossy(&normalized);
+
+        assert_eq!(normalized, expected);
+    }
+}
diff --git a/src/parser/stack.rs b/src/parser/stack.rs
new file mode 100644
index 0000000..413b0be
--- /dev/null
+++ b/src/parser/stack.rs
@@ -0,0 +1,405 @@
+use std::{borrow::Cow, ops::Range};
+
+use bstr::ByteSlice;
+use colored::Colorize;
+use delegate::delegate;
+use tap::Pipe;
+use tracing::trace;
+
+use crate::parser::{bytes::Location, Symbol, UnitSymbol};
+
+use super::Scope;
+
+/// A stack models the types in a given source code file.
+///
+/// # Long lived scopes
+///
+/// For any given scope, an element in the scope can't be fully
+/// resolved as they're parsed because its definition may come later.
+/// Similarly, the contents of nested scopes can't be resolved when
+/// they close because they may rely on definitions in an ancestor scope
+/// that haven't yet been parsed.
+///
+/// This means we can't limit the stack to only "in scope items"
+/// like a real stack in an executing program.
+/// Instead, each scope has to be long lived to power lookups
+/// after the file is fully parsed.
+///
+/// # Typed modeling
+///
+/// This is not meant to fully model execution of a program.
+/// Generally the intention is to model type mappings.
+///
+/// This is hard to really express, but easy to show;
+/// the comments and code below signify the kinds of inferences
+/// the modeling is meant to support:
+/// ```not_rust
+/// // Record the package for the file.
+/// package com.example.MyApp;
+///
+/// // Record imports for the file,
+/// // meaning that the symbol `Logger`
+/// // signifies the type `java.util.logging.Logger`.
+/// import java.util.logging.Logger;
+///
+/// // Record that the class is defined in this package,
+/// // meaning `AppFunctions` is `com.example.MyApp.AppFunctions`.
+/// public class AppFunctions {
+///
+///   // Record the mapping of "the variable `logger`
+///   // refers to the type `java.util.logging.Logger`".
+///   //
+///   // Also, implicitly attach the method invocation
+///   // of `java.util.logging.Logger::getLogger(_)`
+///   // to the scope so that when building the call graph,
+///   // public static and constructor methods include this
+///   // in their call graphs.
+///   private static final Logger logger =
+///     Logger.getLogger(TestFunctions.class.getName());
+///
+///   // Record that `AppFunctions` is a constructor
+///   // inside the scope of the class `AppFunctions`,
+///   // meaning its full path is
+///   // `com.example.MyApp.AppFunctions::AppFunctions()`.
+///   public AppFunctions() {
+///     // Resolve `logger` to the type `java.util.logging.Logger`,
+///     // meaning that `com.example.MyApp.AppFunctions::AppFunctions()`
+///     // calls `java.util.logging.Logger::info(String)`.
+///     logger.info("Constructor called");
+///   }
+///
+///   // Record that `simpleMethod` is a method
+///   // inside the scope of the class `AppFunctions`,
+///   // meaning its full path is
+///   // `com.example.MyApp.AppFunctions::simpleMethod()`.
+///   public void simpleMethod() {
+///     // Resolve `logger` to the type `java.util.logging.Logger`,
+///     // meaning that `com.example.MyApp.AppFunctions::simpleMethod()`
+///     // calls `java.util.logging.Logger::info(String)`.
+///     logger.info("simpleMethod called");
+///
+///     // Resolve `doThing(int)` to the type `AppFunctions`,
+///     // meaning that `com.example.MyApp.AppFunctions::simpleMethod()`
+///     // calls `com.example.MyApp.AppFunctions::doThing(int)`.
+///     doThing(5);
+///
+///     // Resolve `computeThing()` to the type `AppFunctions`,
+///     // meaning that `com.example.MyApp.AppFunctions::simpleMethod()`
+///     // calls `com.example.MyApp.AppFunctions::computeThing()`.
+///     //
+///     // Additionally, record that it returns a `String`,
+///     // so that we can map it to the correct overload
+///     // (which here is `java.util.logging.Logger::info(String)`).
+///     logger.info(computeThing());
+///   }
+///
+///   // Record that `doThing(int)` is a method
+///   // inside the scope of the class `AppFunctions`,
+///   // meaning its full path is
+///   // `com.example.MyApp.AppFunctions::doThing(int)`.
+///   public int doThing(int a) {
+///     return a;
+///   }
+///
+///   // Record that `computeThing()` is a method
+///   // inside the scope of the class `AppFunctions`,
+///   // meaning its full path is
+///   // `com.example.MyApp.AppFunctions::computeThing()`.
+///   public string computeThing() {
+///     return "";
+///   }
+/// ```
+#[derive(Debug, Clone)]
+pub struct Stack<T: Node> {
+    entries: Vec<Entry<T>>,
+    scope_enters: usize,
+    scope_exits: usize,
+}
+
+impl<T: Node> PartialEq for Stack<T> {
+    fn eq(&self, other: &Self) -> bool {
+        self.entries == other.entries
+    }
+}
+
+impl<T: Node> Eq for Stack<T> {}
+
+/// All stack nodes must comply with this trait to facilitate operation & debugging.
+pub trait Node: PartialEq + std::fmt::Debug {}
+impl<T: PartialEq + std::fmt::Debug> Node for T {}
+
+macro_rules! scope_indent {
+    ($stack:ident => $($arg:tt)*) => {{
+        let inner = format!($($arg)*);
+        format!("{:indent$}{inner}", "", indent = $stack.scope_level())
+    }};
+}
+
+impl<T: Node> Stack<T> {
+    /// Enter a new scope on the stack.
+    pub fn enter(&mut self, location: impl Into<Location>) {
+        let loc = location.into();
+        let entry = UnitSymbol::from(loc).pipe(Entry::Enter);
+        self.entries.push(entry);
+
+        trace!(%loc, "{}", scope_indent!(self => "scope_enter"));
+        self.scope_enters += 1;
+    }
+
+    /// Exit the current scope on the stack.
+    pub fn exit(&mut self, location: impl Into<Location>) {
+        let loc = location.into();
+        let entry = UnitSymbol::from(loc).pipe(Entry::Exit);
+        self.entries.push(entry);
+
+        self.scope_exits += 1;
+        trace!(%loc, "{}", scope_indent!(self => "scope_exit"));
+
+        debug_assert!(
+            self.scope_enters >= self.scope_exits,
+            "scope enter count ({}) must be >= exit count ({}) when a scope is exited",
+            self.scope_enters,
+            self.scope_exits,
+        );
+    }
+
+    /// Push a new symbol onto the stack.
+    pub fn push(&mut self, symbol: impl Into<Symbol<T>>) {
+        let symbol = symbol.into();
+        trace!(loc = %symbol.location, "{}", scope_indent!(self => "push: {symbol:?}"));
+
+        let symbol = Entry::Symbol(symbol);
+        self.entries.push(symbol);
+    }
+
+    /// Retrace the stack, reporting all the symbols in scope.
+    /// Symbols are reported in the inverse order that they are added to the stack.
+    #[tracing::instrument(skip_all)]
+    pub fn retrace(&self) -> impl Iterator<Item = &Symbol<T>> {
+        self.entries.iter().rev().pipe(ScopedStackIterator::new)
+    }
+
+    /// Retrace the stack, reporting all the symbols in scope
+    /// starting at the given symbol in the stack,
+    /// not including the search symbol itself.
+    /// Symbols are reported in the inverse order that they are added to the stack.
+    ///
+    /// If the given symbol is not found in the stack, the returned vector is empty.
+    #[tracing::instrument(skip_all)]
+    pub fn retrace_from<'a, 'b: 'a>(
+        &'a self,
+        symbol: &'b Symbol<T>,
+    ) -> impl Iterator<Item = &'a Symbol<T>> {
+        self.entries
+            .iter()
+            .rev()
+            .skip_while(move |entry| entry != symbol)
+            .skip(1)
+            .pipe(ScopedStackIterator::new)
+    }
+
+    /// Iterate through the symbols in the stack.
+    #[tracing::instrument(skip_all)]
+    pub fn symbols(&self) -> impl Iterator<Item = &Symbol<T>> {
+        self.entries.iter().filter_map(|entry| match entry {
+            Entry::Symbol(sy) => Some(sy),
+            _ => None,
+        })
+    }
+
+    /// Returns a formatted string representing the input,
+    /// where the search symbol and its scope are highlighted.
+    ///
+    /// - Italic text is the actual symbol for which scope is being reported.
+    /// - Dimmed text in the string is not part of the current scope.
+    ///   It may be out of scope, or may not have been parsed at all.
+    /// - Normal text in the string is part of the current scope.
+    #[tracing::instrument(skip_all)]
+    pub fn render_scope(&self, content: &[u8], search: &Symbol<T>) -> String {
+        content
+            .grapheme_indices()
+            .map(|(start, end, chunk)| {
+                // The end index provided is exclusive, but `Location` assumes
+                // inclusive end index.
+                (start..end.saturating_sub(1), chunk)
+            })
+            .map(|(location, chunk)| {
+                if search.location.encloses_range(&location) {
+                    Cow::Owned(chunk.italic().to_string())
+                } else if self.in_context_from(search, &location) {
+                    Cow::Borrowed(chunk)
+                } else {
+                    Cow::Owned(chunk.dimmed().to_string())
+                }
+            })
+            .collect()
+    }
+
+    /// Report whether a given byte range is in the context of the parsed stack,
+    /// starting from the provided search node.
+    #[tracing::instrument(skip_all)]
+    fn in_context_from(&self, symbol: &Symbol<T>, search: &Range<usize>) -> bool {
+        // No attempt being made to build a more efficient index
+        // because premature optimization.
+        // If this becomes a problem, consider using an interval tree
+        // or some similar structure.
+        self.retrace_from(symbol)
+            .any(|entry| entry.location().encloses_range(search))
+    }
+
+    fn scope_level(&self) -> usize {
+        self.scope_enters.saturating_sub(self.scope_exits)
+    }
+
+    delegate! {
+        to self.entries {
+            /// Iterate over the entries in the stack.
+            ///
+            /// Note that `retrace` and `retrace_from`
+            /// are usually more useful.
+            pub fn iter(&self) -> impl Iterator<Item = &Entry<T>>;
+
+            /// Get the last entry in the stack.
+            pub fn last(&self) -> Option<&Entry<T>>;
+
+            /// Check whether the stack is empty.
+            pub fn is_empty(&self) -> bool;
+        }
+    }
+}
+
+impl<T: Node> FromIterator<Entry<T>> for Stack<T> {
+    fn from_iter<I: IntoIterator<Item = Entry<T>>>(iter: I) -> Self {
+        let mut stack = Self::default();
+        for entry in iter {
+            match entry {
+                Entry::Enter(entry) => stack.enter(entry.location),
+                Entry::Exit(entry) => stack.exit(entry.location),
+                Entry::Symbol(sy) => stack.push(sy),
+            }
+        }
+        stack
+    }
+}
+
+/// Manually implemented because the derive based implementation
+/// generates code that for some reason requires `T` to implement
+/// `Default`, even though this doesn't generate a default
+/// value of `T` (just a default `Vec<T>` that holds it).
+impl<T: Node> Default for Stack<T> {
+    fn default() -> Self {
+        Self {
+            entries: Default::default(),
+            scope_enters: Default::default(),
+            scope_exits: Default::default(),
+        }
+    }
+}
+
+/// Tracks the items required for the stack to perform its duties.
+///
+/// Note that since entries can be used as cursors, it's important
+/// that entries contain information that allows different entries
+/// with the same name to be disambiguated.
+/// An easy way to do this is by including their location:
+/// a given symbol can only appear in the source code in one place.
+///
+/// Some types (such as [`Symbol`]) already include location
+/// and are therefore inherently able to disambuguate entries.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum Entry<T: Node> {
+    /// Indicates that a scope has been entered.
+    Enter(UnitSymbol),
+
+    /// Indicates that a scope has been closed.
+    Exit(UnitSymbol),
+
+    /// Indicates a symbol in the currently active scope.
+    Symbol(Symbol<T>),
+}
+
+impl<T: Node> Entry<T> {
+    /// The location of the entry in the source code, regardless of variant.
+    pub fn location(&self) -> Location {
+        match self {
+            Entry::Enter(s) => s.location(),
+            Entry::Exit(s) => s.location(),
+            Entry::Symbol(s) => s.location(),
+        }
+    }
+}
+
+impl<T: Node> PartialEq<Symbol<T>> for &Entry<T> {
+    fn eq(&self, other: &Symbol<T>) -> bool {
+        match self {
+            Entry::Symbol(symbol) => symbol == other,
+            _ => false,
+        }
+    }
+}
+
+impl<T: Node> From<Symbol<T>> for Entry<T> {
+    fn from(value: Symbol<T>) -> Self {
+        Self::Symbol(value)
+    }
+}
+
+impl<T: Node> From<Scope> for Entry<T> {
+    fn from(value: Scope) -> Self {
+        match value {
+            Scope::Enter(loc) => Symbol::new((), loc).pipe(Self::Enter),
+            Scope::Exit(loc) => Symbol::new((), loc).pipe(Self::Exit),
+        }
+    }
+}
+
+/// Iterates over entries in [`Stack`],
+/// dropping entries that are not in the current scope.
+///
+/// Important: this assumes it is iterating the stack in reverse.
+/// Since this is so easy to misuse, this type really shouldn't be public.
+struct ScopedStackIterator<I> {
+    iter: I,
+}
+
+impl<I> ScopedStackIterator<I> {
+    /// Drops stack entries that are not in the current scope.
+    /// Important: this assumes it is iterating the stack in reverse.
+    fn new(iter: I) -> Self {
+        Self { iter }
+    }
+}
+
+impl<'a, T, I> Iterator for ScopedStackIterator<I>
+where
+    Self: 'a,
+    T: 'a + Node,
+    I: Iterator<Item = &'a Entry<T>>,
+{
+    type Item = &'a Symbol<T>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        match self.iter.next()? {
+            // Multiple exits may come one after another.
+            // Keep a running count until the same number of enters have been passed.
+            Entry::Exit(_) => {
+                let mut exit_count = 1usize;
+                for entry in self.iter.by_ref() {
+                    match entry {
+                        Entry::Enter(_) => exit_count = exit_count.saturating_sub(1),
+                        Entry::Exit(_) => exit_count += 1,
+                        _ => {}
+                    }
+                    if exit_count == 0 {
+                        break;
+                    }
+                }
+                self.next()
+            }
+            // Don't touch exit count here:
+            // this is only reached when walking unclosed scope.
+            Entry::Enter(_) => self.next(),
+            Entry::Symbol(symbol) => Some(symbol),
+        }
+    }
+}
diff --git a/src/text.rs b/src/text.rs
index 0b11d40..77cf0e0 100644
--- a/src/text.rs
+++ b/src/text.rs
@@ -1,23 +1,20 @@
 //! Text based operations on byte streams and strings.
 
+use std::{borrow::Cow, ops::Deref};
+
 use base64::Engine;
+use derive_more::{Deref, Index};
 use sha2::{Digest, Sha256};
-use tap::Pipe;
-
-pub use buffer::Buffer;
-pub use normalize_lines::*;
-pub use normalize_space::*;
+use tap::{Conv, Pipe};
+use thiserror::Error;
 
-pub mod buffer;
-mod normalize_lines;
-mod normalize_space;
+use crate::parser::normalize;
 
 /// Given a buffer, produce a fingerprint of its contents.
 pub fn fingerprint(input: impl AsRef<[u8]>) -> Buffer {
-    // Using an iterator here because according to the rough benchmarks it's much faster than cloning into vec.
-    let normalized_line_endings = input.as_ref().iter().copied().convert_crlf_lf();
+    let normalized_line_endings = normalize::crlf(input.as_ref());
     let mut hasher = Sha256::new();
-    for c in normalized_line_endings {
+    for &c in normalized_line_endings.deref() {
         hasher.update([c]);
     }
     hasher.finalize().as_slice().pipe(Buffer::new)
@@ -27,3 +24,101 @@ pub fn fingerprint(input: impl AsRef<[u8]>) -> Buffer {
 pub fn as_base64(input: impl AsRef<[u8]>) -> String {
     base64::engine::general_purpose::STANDARD_NO_PAD.encode(input)
 }
+
+/// Errors reported when decoding a buffer.
+#[derive(Debug, Error)]
+pub enum Error {
+    #[error("decode base64 input")]
+    DecodeBase64(#[from] DecodeBase64Error),
+}
+
+/// The kind of encoding to use when displaying the buffer.
+#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub enum Encoding {
+    /// Indicate the buffer was created with arbitrary bytes.
+    Bytes(Vec<u8>),
+
+    /// Indicate the buffer was created with UTF8 text.
+    UTF8(String),
+}
+
+/// A byte buffer that reports its value in a more human-readable form.
+#[derive(Clone, PartialEq, Eq, Hash, PartialOrd, Ord, Index, Deref)]
+pub struct Buffer {
+    encoding: Encoding,
+}
+
+impl Buffer {
+    fn new_internal(encoding: Encoding) -> Self {
+        Self { encoding }
+    }
+
+    /// Create a new buffer from arbitrary bytes.
+    pub fn new(input: impl Into<Vec<u8>>) -> Self {
+        let input = input.into();
+        String::from_utf8(input)
+            .map(Encoding::UTF8)
+            .unwrap_or_else(|err| err.into_bytes().pipe(Encoding::Bytes))
+            .pipe(Self::new_internal)
+    }
+
+    /// Decode a string into an instance.
+    pub fn utf8(input: impl Into<String>) -> Self {
+        input
+            .conv::<String>()
+            .pipe(Encoding::UTF8)
+            .pipe(Self::new_internal)
+    }
+
+    /// Decode a base64 string into an instance.
+    pub fn base64(input: impl AsRef<str>) -> Result<Self, Error> {
+        base64::engine::general_purpose::STANDARD_NO_PAD
+            .decode(input.as_ref())
+            .map_err(Error::from)
+            .map(Self::new)
+    }
+
+    /// Read the buffer as a `Vec<u8>`.
+    pub fn as_bytes(&self) -> &[u8] {
+        match &self.encoding {
+            Encoding::Bytes(v) => v,
+            Encoding::UTF8(s) => s.as_bytes(),
+        }
+    }
+
+    /// Read the buffer as a `String`.
+    /// If the buffer isn't a valid string already, returns the base64 encoded equivalent.
+    pub fn as_utf8(&self) -> Cow<'_, str> {
+        match &self.encoding {
+            Encoding::Bytes(v) => as_base64(v).pipe(Cow::from),
+            Encoding::UTF8(s) => Cow::from(s),
+        }
+    }
+}
+
+impl std::fmt::Display for Buffer {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let repr = match &self.encoding {
+            Encoding::UTF8(s) => Cow::from(s),
+            Encoding::Bytes(b) => as_base64(b).pipe(Cow::from),
+        };
+        f.write_str(&repr)
+    }
+}
+
+impl std::fmt::Debug for Buffer {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "Buffer('{self}')")
+    }
+}
+
+/// An error that occurs when trying to decode into a buffer.
+#[derive(Debug, Error)]
+#[error(transparent)]
+pub struct DecodeBase64Error(#[from] base64::DecodeError);
+
+impl From<base64::DecodeError> for Error {
+    fn from(value: base64::DecodeError) -> Self {
+        DecodeBase64Error(value).pipe(Self::DecodeBase64)
+    }
+}
diff --git a/src/text/buffer.rs b/src/text/buffer.rs
deleted file mode 100644
index 96924e7..0000000
--- a/src/text/buffer.rs
+++ /dev/null
@@ -1,106 +0,0 @@
-use std::borrow::Cow;
-
-use base64::Engine;
-use derive_more::{Deref, Index};
-use tap::{Conv, Pipe};
-use thiserror::Error;
-
-use crate::text::as_base64;
-
-/// Errors reported when decoding a buffer.
-#[derive(Debug, Error)]
-pub enum Error {
-    #[error("decode base64 input")]
-    DecodeBase64(#[from] DecodeBase64Error),
-}
-
-/// The kind of encoding to use when displaying the buffer.
-#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-pub enum Encoding {
-    /// Indicate the buffer was created with arbitrary bytes.
-    Bytes(Vec<u8>),
-
-    /// Indicate the buffer was created with UTF8 text.
-    UTF8(String),
-}
-
-/// A byte buffer that reports its value in a more human-readable form.
-#[derive(Clone, PartialEq, Eq, Hash, PartialOrd, Ord, Index, Deref)]
-pub struct Buffer {
-    encoding: Encoding,
-}
-
-impl Buffer {
-    fn new_internal(encoding: Encoding) -> Self {
-        Self { encoding }
-    }
-
-    /// Create a new buffer from arbitrary bytes.
-    pub fn new(input: impl Into<Vec<u8>>) -> Self {
-        let input = input.into();
-        String::from_utf8(input)
-            .map(Encoding::UTF8)
-            .unwrap_or_else(|err| err.into_bytes().pipe(Encoding::Bytes))
-            .pipe(Self::new_internal)
-    }
-
-    /// Decode a string into an instance.
-    pub fn utf8(input: impl Into<String>) -> Self {
-        input
-            .conv::<String>()
-            .pipe(Encoding::UTF8)
-            .pipe(Self::new_internal)
-    }
-
-    /// Decode a base64 string into an instance.
-    pub fn base64(input: impl AsRef<str>) -> Result<Self, Error> {
-        base64::engine::general_purpose::STANDARD_NO_PAD
-            .decode(input.as_ref())
-            .map_err(Error::from)
-            .map(Self::new)
-    }
-
-    /// Read the buffer as a `Vec<u8>`.
-    pub fn as_bytes(&self) -> &[u8] {
-        match &self.encoding {
-            Encoding::Bytes(v) => v,
-            Encoding::UTF8(s) => s.as_bytes(),
-        }
-    }
-
-    /// Read the buffer as a `String`.
-    /// If the buffer isn't a valid string already, returns the base64 encoded equivalent.
-    pub fn as_utf8(&self) -> Cow<'_, str> {
-        match &self.encoding {
-            Encoding::Bytes(v) => as_base64(v).pipe(Cow::from),
-            Encoding::UTF8(s) => Cow::from(s),
-        }
-    }
-}
-
-impl std::fmt::Display for Buffer {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let repr = match &self.encoding {
-            Encoding::UTF8(s) => Cow::from(s),
-            Encoding::Bytes(b) => as_base64(b).pipe(Cow::from),
-        };
-        f.write_str(&repr)
-    }
-}
-
-impl std::fmt::Debug for Buffer {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "Buffer('{self}')")
-    }
-}
-
-/// An error that occurs when trying to decode into a buffer.
-#[derive(Debug, Error)]
-#[error(transparent)]
-pub struct DecodeBase64Error(#[from] base64::DecodeError);
-
-impl From<base64::DecodeError> for Error {
-    fn from(value: base64::DecodeError) -> Self {
-        DecodeBase64Error(value).pipe(Self::DecodeBase64)
-    }
-}
diff --git a/src/text/normalize_lines.rs b/src/text/normalize_lines.rs
deleted file mode 100644
index bab9b2c..0000000
--- a/src/text/normalize_lines.rs
+++ /dev/null
@@ -1,56 +0,0 @@
-use std::iter::Peekable;
-
-const CR_CHAR: u8 = b'\r';
-const LF_CHAR: u8 = b'\n';
-
-/// Implements the ability to drop `\r\n` byte pairs from an iterator, converting each instance to a single `\n`.
-pub struct CRLFToLF<I>
-where
-    I: Iterator<Item = u8>,
-{
-    iter: Peekable<I>,
-}
-
-impl<I> Iterator for CRLFToLF<I>
-where
-    I: Iterator<Item = u8>,
-{
-    type Item = u8;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        let current = self.iter.next()?;
-        if current == CR_CHAR && self.iter.peek() == Some(&LF_CHAR) {
-            self.next()
-        } else {
-            Some(current)
-        }
-    }
-}
-
-impl<I> CRLFToLF<I>
-where
-    I: Iterator<Item = u8>,
-{
-    fn new(iter: I) -> Self {
-        Self {
-            iter: iter.peekable(),
-        }
-    }
-}
-
-pub trait ConvertCRLFToLF {
-    /// Drop `\r\n` byte pairs from an iterator, converting each instance to a single `\n`.
-    fn convert_crlf_lf(self) -> CRLFToLF<Self>
-    where
-        Self: Sized,
-        Self: Iterator<Item = u8>;
-}
-
-impl<I> ConvertCRLFToLF for I
-where
-    I: Iterator<Item = u8>,
-{
-    fn convert_crlf_lf(self) -> CRLFToLF<Self> {
-        CRLFToLF::new(self)
-    }
-}
diff --git a/src/text/normalize_space.rs b/src/text/normalize_space.rs
deleted file mode 100644
index 30bf389..0000000
--- a/src/text/normalize_space.rs
+++ /dev/null
@@ -1,31 +0,0 @@
-use std::borrow::Cow;
-
-use once_cell::sync::Lazy;
-use regex::bytes::Regex;
-
-static MULTI_SPACES: Lazy<Regex> = Lazy::new(|| Regex::new(r"\s+").expect("regex must be valid"));
-
-/// Normalize any consecutive whitespace into a single space.
-#[tracing::instrument(skip_all)]
-pub fn normalize_space(text: &[u8]) -> Cow<'_, [u8]> {
-    MULTI_SPACES.replace_all(text.as_ref(), b" ")
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn multi_spaces_compiles() {
-        let _ = MULTI_SPACES;
-    }
-
-    #[test]
-    fn normalizes_spaces() {
-        let input = b"Sit  dolorem\nconsequatur tenetur \n porro\n\naspernatur\t\n .";
-        //               ^^       ^            ^       ^^ ^     ^ ^           ^ ^ ^
-
-        let expected = b"Sit dolorem consequatur tenetur porro aspernatur .";
-        assert_eq!(normalize_space(input).as_ref(), expected);
-    }
-}
diff --git a/tests/it/language.rs b/tests/it/language.rs
index 78dbb12..eaf7f9b 100644
--- a/tests/it/language.rs
+++ b/tests/it/language.rs
@@ -1,2 +1,3 @@
 pub mod c99_tc3;
 pub mod cpp_98;
+pub mod java_11;
diff --git a/tests/it/language/c99_tc3.rs b/tests/it/language/c99_tc3.rs
index 950dffe..d155d09 100644
--- a/tests/it/language/c99_tc3.rs
+++ b/tests/it/language/c99_tc3.rs
@@ -1,9 +1,10 @@
 use itertools::Itertools;
 use pretty_assertions::assert_eq;
 use snippets::{
-    language::c99_tc3, Extractor, Kind, Kinds, Location, Metadata, Method, Options, Snippet,
-    Target, Targets, Transform, Transforms,
+    content::Content, language::c99_tc3, parser::bytes::Location, Extractor, Kind, Kinds, Metadata,
+    Method, Options, Snippet, Target, Targets, Transform, Transforms,
 };
+use tap::Pipe;
 
 use crate::include_str_lf;
 
@@ -41,7 +42,8 @@ fn full_raw_hello_world_crlf_lf() {
     //
     // On non-Windows the first replace will just effectively do nothing.
     let content_lf = include_str!("testdata/c99_tc3/hello_world.c").replace("\r\n", "\n");
-    let content_crlf = content_lf.replace('\n', "\r\n");
+    let content_crlf = content_lf.replace('\n', "\r\n").pipe(Content::from);
+    let content_lf = Content::from(content_lf);
 
     let opts = Options::new(Target::Function, kind, Transforms::from(transform));
     let extract_lf = c99_tc3::Extractor::extract(&opts, &content_lf).unwrap();
@@ -80,6 +82,7 @@ fn full_raw_hello_world_syntax_error() {
     let span = Location::from(21..=68);
 
     let content = include_str_lf!("testdata/c99_tc3/hello_world_error.c");
+
     let opts = Options::new(Target::Function, kind, Transforms::from(transform));
     let extract = c99_tc3::Extractor::extract(&opts, &content).expect("must set up parser");
 
@@ -141,7 +144,7 @@ fn full_space_hello_world() {
 
     let content = include_str_lf!("testdata/c99_tc3/hello_world.c");
     let opts = Options::new(Target::Function, kind, transform).disable_raw();
-    let extract = c99_tc3::Extractor::extract(&opts, content).expect("must set up parser");
+    let extract = c99_tc3::Extractor::extract(&opts, &content).expect("must set up parser");
 
     let expected = vec![Snippet::from(
         Metadata::new(kind, transform.into(), span),
@@ -221,7 +224,7 @@ fn full_comment_hello_world_comment() {
 
     let content = include_str_lf!("testdata/c99_tc3/hello_world_comment.c");
     let opts = Options::new(Target::Function, kind, transform).disable_raw();
-    let extract = c99_tc3::Extractor::extract(&opts, content).expect("must set up parser");
+    let extract = c99_tc3::Extractor::extract(&opts, &content).expect("must set up parser");
 
     let expected_content = r#"int  main  () 
 { 
@@ -252,7 +255,7 @@ fn signature_comment_hello_world_comment() {
 
     let content = include_str_lf!("testdata/c99_tc3/hello_world_comment.c");
     let opts = Options::new(Target::Function, kind, transform).disable_raw();
-    let extract = c99_tc3::Extractor::extract(&opts, content).expect("must set up parser");
+    let extract = c99_tc3::Extractor::extract(&opts, &content).expect("must set up parser");
 
     let expected_content = r#"int  main  () "#;
 
@@ -274,7 +277,7 @@ fn signature_comment_complicated() {
 
     let content = include_str_lf!("testdata/c99_tc3/signature_comment.c");
     let opts = Options::new(Target::Function, kind, transform).disable_raw();
-    let extract = c99_tc3::Extractor::extract(&opts, content).expect("must set up parser");
+    let extract = c99_tc3::Extractor::extract(&opts, &content).expect("must set up parser");
 
     let expected_content = r"static int comp_method_zlib_comp(LIBSSH2_SESSION *session, unsigned char *dest, size_t *dest_len, const unsigned char *src, size_t src_len, void **abstract)";
     let expected = vec![Snippet::from(
@@ -295,7 +298,7 @@ fn body_comment_complicated() {
 
     let content = include_str_lf!("testdata/c99_tc3/signature_comment.c");
     let opts = Options::new(Target::Function, kind, transform).disable_raw();
-    let extract = c99_tc3::Extractor::extract(&opts, content).expect("must set up parser");
+    let extract = c99_tc3::Extractor::extract(&opts, &content).expect("must set up parser");
 
     let expected_content = r#"{ z_stream *strm = *abstract; int out_maxlen = *dest_len; int status; strm->next_in = (unsigned char *) src; strm->avail_in = src_len; strm->next_out = dest; strm->avail_out = out_maxlen; status = deflate(strm, Z_PARTIAL_FLUSH); if((status == Z_OK) && (strm->avail_out > 0)) { *dest_len = out_maxlen - strm->avail_out; return 0; } _libssh2_debug(session, LIBSSH2_TRACE_TRANS, "unhandled zlib compression error %d, avail_out", status, strm->avail_out); return _libssh2_error(session, LIBSSH2_ERROR_ZLIB, "compression failure"); }"#;
     let expected = vec![Snippet::from(
@@ -316,7 +319,7 @@ fn body_comment_hello_world_comment() {
 
     let content = include_str_lf!("testdata/c99_tc3/hello_world_comment.c");
     let opts = Options::new(Target::Function, kind, transform).disable_raw();
-    let extract = c99_tc3::Extractor::extract(&opts, content).expect("must set up parser");
+    let extract = c99_tc3::Extractor::extract(&opts, &content).expect("must set up parser");
 
     let expected_content = r#"{ 
   
@@ -346,7 +349,7 @@ fn full_code_hello_world_comment() {
 
     let content = include_str_lf!("testdata/c99_tc3/hello_world_comment.c");
     let opts = Options::new(Target::Function, kind, transform).disable_raw();
-    let extract = c99_tc3::Extractor::extract(&opts, content).expect("must set up parser");
+    let extract = c99_tc3::Extractor::extract(&opts, &content).expect("must set up parser");
 
     let expected_content = r#"int main () { printf("hello world\n" ); return 0 ; }"#;
 
@@ -368,7 +371,7 @@ fn signature_code_hello_world_comment() {
 
     let content = include_str_lf!("testdata/c99_tc3/hello_world_comment.c");
     let opts = Options::new(Target::Function, kind, transform).disable_raw();
-    let extract = c99_tc3::Extractor::extract(&opts, content).expect("must set up parser");
+    let extract = c99_tc3::Extractor::extract(&opts, &content).expect("must set up parser");
 
     let expected_content = r#"int main () "#;
 
@@ -390,7 +393,7 @@ fn body_code_hello_world_comment() {
 
     let content = include_str_lf!("testdata/c99_tc3/hello_world_comment.c");
     let opts = Options::new(Target::Function, kind, transform).disable_raw();
-    let extract = c99_tc3::Extractor::extract(&opts, content).expect("must set up parser");
+    let extract = c99_tc3::Extractor::extract(&opts, &content).expect("must set up parser");
 
     let expected_content = r#"{ printf("hello world\n" ); return 0 ; }"#;
 
@@ -412,6 +415,6 @@ fn smoke_test() {
 
     let content = include_str_lf!("testdata/c99_tc3/smoke_comp.c");
     let opts = Options::new(target, kind, transform).disable_raw();
-    let extract = c99_tc3::Extractor::extract(&opts, content).expect("extract snippets");
+    let extract = c99_tc3::Extractor::extract(&opts, &content).expect("extract snippets");
     assert!(!extract.is_empty(), "must have extracted snippets");
 }
diff --git a/tests/it/language/cpp_98.rs b/tests/it/language/cpp_98.rs
index 69439f3..2a57cb3 100644
--- a/tests/it/language/cpp_98.rs
+++ b/tests/it/language/cpp_98.rs
@@ -1,6 +1,6 @@
 use snippets::{
-    language::cpp_98, Extractor, Kind, Kinds, Location, Metadata, Options, Snippet, Target,
-    Targets, Transform, Transforms,
+    language::cpp_98, parser::bytes::Location, Extractor, Kind, Kinds, Metadata, Options, Snippet,
+    Target, Targets, Transform, Transforms,
 };
 
 use crate::include_str_lf;
@@ -15,7 +15,7 @@ fn smoke_test() {
 
     let content = include_str_lf!("testdata/cpp_98/smoke_test.cc");
     let opts = Options::new(target, kind, transform).disable_raw();
-    let extract = cpp_98::Extractor::extract(&opts, content).expect("extract snippets");
+    let extract = cpp_98::Extractor::extract(&opts, &content).expect("extract snippets");
     assert!(!extract.is_empty(), "must have extracted snippets");
 }
 
@@ -50,7 +50,7 @@ fn functions_in_namespaces_full_comment_normalized() {
     let content = include_str_lf!("testdata/cpp_98/bare_function_in_namespace.cc");
     let opts = Options::new(Target::Function, kind, transform).disable_raw();
 
-    let extract = cpp_98::Extractor::extract(&opts, content).expect("extract snippets");
+    let extract = cpp_98::Extractor::extract(&opts, &content).expect("extract snippets");
     let expected = vec![Snippet::from(
         Metadata::new(kind, transform.into(), helloworld_span),
         r#"int main() {
@@ -130,7 +130,7 @@ fn function_in_class_full_comment() {
     let content = include_str_lf!("testdata/cpp_98/simple_class.cc");
     let opts = Options::new(Target::Function, kind, transform).disable_raw();
 
-    let extract = cpp_98::Extractor::extract(&opts, content).expect("extract snippets");
+    let extract = cpp_98::Extractor::extract(&opts, &content).expect("extract snippets");
     let expected = vec![
         Snippet::from(
             Metadata::new(kind, transform.into(), member_method_span),
@@ -174,7 +174,7 @@ fn function_in_class_full_code() {
     let content = include_str_lf!("testdata/cpp_98/simple_class.cc");
     let opts = Options::new(Target::Function, kind, transform).disable_raw();
 
-    let extract = cpp_98::Extractor::extract(&opts, content).expect("extract snippets");
+    let extract = cpp_98::Extractor::extract(&opts, &content).expect("extract snippets");
     let expected = vec![
         Snippet::from(
             Metadata::new(kind, transform.into(), member_method_span),
diff --git a/tests/it/language/java_11.rs b/tests/it/language/java_11.rs
new file mode 100644
index 0000000..e938b81
--- /dev/null
+++ b/tests/it/language/java_11.rs
@@ -0,0 +1,194 @@
+use pretty_assertions::assert_eq;
+use snippets::{
+    language::java_11::{self, Node},
+    parser::{bytes::Location, stack::Stack, Argument, Parameter, Scope, Symbol, Visibility},
+    Extractor, Kind, Metadata, Method, Snippet,
+};
+
+use crate::include_str_lf;
+
+const PUBLIC: Visibility = Visibility::Public;
+const ANY_PARAM: Parameter = Parameter::Variadic(Argument::Any);
+const ANY_ARG: Argument = Argument::Any;
+
+macro_rules! node {
+    ($loc:expr, $constructor:ident, $($args:expr),* $(,)*) => {
+        Symbol::new(Node::$constructor($($args,)*), $loc).into()
+    };
+}
+
+macro_rules! scope_enter {
+    ($loc:expr) => {
+        Scope::new_enter($loc).into()
+    };
+}
+
+macro_rules! scope_exit {
+    ($loc:expr) => {
+        Scope::new_exit($loc).into()
+    };
+}
+
+#[test]
+fn call_graph_smoke_test() {
+    crate::tracing::setup();
+
+    let options = java_11::EmptyOptions;
+    let content = include_str_lf!("testdata/java_11/with_package.java");
+    let extract = java_11::CallGraphExtractor::extract(&options, &content).expect("set up parser");
+
+    // Using /**/ to indicate each level of scope and macros to keep it all on one line
+    // so that this is at least somewhat readable...
+    let expected = Stack::<java_11::Node>::from_iter([
+        node!(8..25, new_package, "com.example.MyApp"),
+        node!(35..52, new_import, "java.util.HashMap"),
+        node!(61..85, new_import, "java.util.logging.Logger"),
+        node!(164..176, new_class, PUBLIC, "AppFunctions"),
+        scope_enter!(177..178),
+        /**/ node!(240..253, new_variable, PUBLIC, "logger", "Logger"),
+        /**/ node!(256..303, new_invocation, "getLogger", "Logger", []),
+        /**/ node!(293..302, new_invocation, "getName", "this", []),
+        /**/ node!(344..358, new_constructor, PUBLIC, "AppFunctions", []),
+        /**/ scope_enter!(359..360),
+        /**/ /**/ node!(369..402, new_invocation, "info", "logger", ANY_ARG),
+        /**/ /**/ scope_exit!(408..409),
+        /**/ node!(479..493, new_method, PUBLIC, "simpleMethod", []),
+        /**/ scope_enter!(494..495),
+        /**/ /**/ node!(504..538, new_invocation, "info", "logger", ANY_ARG),
+        /**/ /**/ node!(548..566, new_invocation, "methodWithParam", "this", ANY_ARG),
+        /**/ /**/ scope_exit!(598..599),
+        /**/ node!(667..689, new_method, PUBLIC, "methodWithParam", ANY_PARAM),
+        /**/ scope_enter!(690..691),
+        /**/ /**/ node!(700..758, new_invocation, "info", "logger", ANY_ARG),
+        /**/ /**/ scope_exit!(782..783),
+        /**/ node!(845..874, new_method, PUBLIC, "methodWithParam", ANY_PARAM),
+        /**/ scope_enter!(875..876),
+        /**/ /**/ node!(885..965, new_invocation, "info", "logger", ANY_ARG),
+        /**/ /**/ node!(975..989, new_invocation, "staticMethod", "this", []),
+        /**/ /**/ scope_exit!(1044..1045),
+        /**/ node!(1095..1105, new_class, PUBLIC, "InnerClass"),
+        /**/ scope_enter!(1106..1107),
+        /**/ /**/ node!(1123..1135, new_constructor, PUBLIC, "InnerClass", []),
+        /**/ /**/ scope_enter!(1136..1137),
+        /**/ /**/ /**/ node!(1150..1194, new_invocation, "info", "logger", ANY_ARG),
+        /**/ /**/ /**/ scope_exit!(1204..1205),
+        /**/ /**/ scope_exit!(1210..1211),
+        /**/ node!(1275..1291, new_class, PUBLIC, "StaticInnerClass"),
+        /**/ scope_enter!(1292..1293),
+        /**/ /**/ node!(1309..1327, new_constructor, PUBLIC, "StaticInnerClass", []),
+        /**/ /**/ scope_enter!(1328..1329),
+        /**/ /**/ /**/ node!(1342..1392, new_invocation, "info", "logger", ANY_ARG),
+        /**/ /**/ /**/ scope_exit!(1402..1403),
+        /**/ /**/ scope_exit!(1408..1409),
+        /**/ scope_exit!(1410..1411),
+    ]);
+
+    assert_eq!(expected, extract);
+}
+
+#[test]
+fn smoke_test() {
+    crate::tracing::setup();
+
+    let kind = Kind::Full;
+    let transform = None;
+
+    let options = java_11::EmptyOptions;
+    let content = include_str_lf!("testdata/java_11/smoke_test.java");
+    let extract = java_11::Extractor::extract(&options, &content).expect("set up parser");
+
+    let expected = vec![
+        Snippet::from(
+            Metadata::new(kind, Method::from(transform), Location::from(247..320)),
+            "public TestFunctions() {\n        logger.info(\"Constructor called\");\n    }".as_bytes(),
+        ),
+        Snippet::from(
+            Metadata::new(kind, Method::from(transform), Location::from(378..510)),
+            "public void simpleMethod() {\n        logger.info(\"simpleMethod called\");\n        methodWithParam(5); // Calling another method\n    }".as_bytes(),
+        ),
+        Snippet::from(
+            Metadata::new(kind, Method::from(transform), Location::from(567..694)),
+            "public int methodWithParam(int a) {\n        logger.info(\"methodWithParam(int a) called with a = \" + a);\n        return a;\n    }".as_bytes(),
+        ),
+        Snippet::from(
+            Metadata::new(kind, Method::from(transform), Location::from(745..956)),
+            "public int methodWithParam(int a, int b) {\n        logger.info(\"methodWithParam(int a, int b) called with a = \" + a + \", b = \" + b);\n        staticMethod(); // Calling a static method\n        return a + b;\n    }".as_bytes(),
+        ),
+        Snippet::from(
+            Metadata::new(kind, Method::from(transform), Location::from(983..1068)),
+            "public static void staticMethod() {\n        logger.info(\"staticMethod called\");\n    }".as_bytes(),
+        ),
+        Snippet::from(
+            Metadata::new(kind, Method::from(transform), Location::from(1096..1234)),
+            "private void privateMethod() {\n        logger.info(\"privateMethod called\");\n        protectedMethod(); // Calling a protected method\n    }".as_bytes(),
+        ),
+        Snippet::from(
+            Metadata::new(kind, Method::from(transform), Location::from(1264..1351)),
+            "protected void protectedMethod() {\n        logger.info(\"protectedMethod called\");\n    }".as_bytes(),
+        ),
+        Snippet::from(
+            Metadata::new(kind, Method::from(transform), Location::from(1396..1575)),
+            "public void methodWithComplexParam(HashMap<String, Integer> map) {\n        logger.info(\"methodWithComplexParam called\");\n        privateMethod(); // Calling a private method\n    }".as_bytes(),
+        ),
+        Snippet::from(
+            Metadata::new(kind, Method::from(transform), Location::from(1608..1918)),
+            "public void methodWithVarargs(String... args) {\n        logger.info(\"methodWithVarargs called with \" + args.length + \" arguments\");\n        // Calling a method with a complex parameter\n        HashMap<String, Integer> map = new HashMap<>();\n        map.put(\"key\", 1);\n        methodWithComplexParam(map);\n    }".as_bytes(),
+        ),
+        Snippet::from(
+            Metadata::new(kind, Method::from(transform), Location::from(1989..2078)),
+            "public InnerClass() {\n            logger.info(\"InnerClass constructor called\");\n        }".as_bytes(),
+        ),
+        Snippet::from(
+            Metadata::new(kind, Method::from(transform), Location::from(2175..2276)),
+            "public StaticInnerClass() {\n            logger.info(\"StaticInnerClass constructor called\");\n        }".as_bytes(),
+        ),
+    ];
+
+    assert_eq!(expected, extract);
+}
+
+#[test]
+fn call_graph_hello_world() {
+    crate::tracing::setup();
+
+    let options = java_11::EmptyOptions;
+    let content = include_str_lf!("testdata/java_11/hello_world.java");
+    let extract = java_11::CallGraphExtractor::extract(&options, &content).expect("set up parser");
+
+    const PUBLIC: Visibility = Visibility::Public;
+    const ANY: Parameter = Parameter::Variadic(Argument::Any);
+
+    // Using /**/ to indicate each level of scope and macros to keep it all on one line
+    // so that this is at least somewhat readable...
+    let expected = Stack::<java_11::Node>::from_iter([
+        node!(7..17, new_class, PUBLIC, "HelloWorld"),
+        scope_enter!(18..19),
+        /**/ node!(43..62, new_method, PUBLIC, "main", ANY),
+        /**/ scope_enter!(63..64),
+        /**/ /**/ node!(73..108, new_invocation, "println", "System.out", ANY_ARG),
+        /**/ /**/ scope_exit!(114..115),
+        /**/ scope_exit!(116..117),
+    ]);
+
+    assert_eq!(expected, extract);
+}
+
+#[test]
+fn full_raw_hello_world() {
+    crate::tracing::setup();
+
+    let kind = Kind::Full;
+    let transform = None;
+    let span = Location::from(24..115);
+
+    let options = java_11::EmptyOptions;
+    let content = include_str_lf!("testdata/java_11/hello_world.java");
+    let extract = java_11::Extractor::extract(&options, &content).expect("set up parser");
+
+    let expected = vec![Snippet::from(
+        Metadata::new(kind, Method::from(transform), span),
+        span.extract_from(content.as_bytes()),
+    )];
+
+    assert_eq!(expected, extract);
+}
diff --git a/tests/it/language/testdata/java_11/hello_world.java b/tests/it/language/testdata/java_11/hello_world.java
new file mode 100644
index 0000000..a8c1a09
--- /dev/null
+++ b/tests/it/language/testdata/java_11/hello_world.java
@@ -0,0 +1,6 @@
+
+class HelloWorld {
+    public static void main(String[] args) {
+        System.out.println("Hello, World!");
+    }
+}
diff --git a/tests/it/language/testdata/java_11/smoke_test.java b/tests/it/language/testdata/java_11/smoke_test.java
new file mode 100644
index 0000000..1229c5c
--- /dev/null
+++ b/tests/it/language/testdata/java_11/smoke_test.java
@@ -0,0 +1,77 @@
+import java.util.HashMap;
+import java.util.logging.Logger;
+
+public class TestFunctions {
+
+    // Logger for logging messages
+    private static final Logger logger = Logger.getLogger(TestFunctions.class.getName());
+
+    // Default constructor
+    public TestFunctions() {
+        logger.info("Constructor called");
+    }
+
+    // Method with no return type and no parameters
+    public void simpleMethod() {
+        logger.info("simpleMethod called");
+        methodWithParam(5); // Calling another method
+    }
+
+    // Method with a return type and one parameter
+    public int methodWithParam(int a) {
+        logger.info("methodWithParam(int a) called with a = " + a);
+        return a;
+    }
+
+    // Overloaded method with two parameters
+    public int methodWithParam(int a, int b) {
+        logger.info("methodWithParam(int a, int b) called with a = " + a + ", b = " + b);
+        staticMethod(); // Calling a static method
+        return a + b;
+    }
+
+    // Static method
+    public static void staticMethod() {
+        logger.info("staticMethod called");
+    }
+
+    // Private method
+    private void privateMethod() {
+        logger.info("privateMethod called");
+        protectedMethod(); // Calling a protected method
+    }
+
+    // Protected method
+    protected void protectedMethod() {
+        logger.info("protectedMethod called");
+    }
+
+    // Method with a complex parameter
+    public void methodWithComplexParam(HashMap<String, Integer> map) {
+        logger.info("methodWithComplexParam called");
+        privateMethod(); // Calling a private method
+    }
+
+    // Method with varargs
+    public void methodWithVarargs(String... args) {
+        logger.info("methodWithVarargs called with " + args.length + " arguments");
+        // Calling a method with a complex parameter
+        HashMap<String, Integer> map = new HashMap<>();
+        map.put("key", 1);
+        methodWithComplexParam(map);
+    }
+
+    // Inner class with a constructor
+    class InnerClass {
+        public InnerClass() {
+            logger.info("InnerClass constructor called");
+        }
+    }
+
+    // Static inner class with a constructor
+    static class StaticInnerClass {
+        public StaticInnerClass() {
+            logger.info("StaticInnerClass constructor called");
+        }
+    }
+}
diff --git a/tests/it/language/testdata/java_11/with_package.java b/tests/it/language/testdata/java_11/with_package.java
new file mode 100644
index 0000000..de50ee5
--- /dev/null
+++ b/tests/it/language/testdata/java_11/with_package.java
@@ -0,0 +1,49 @@
+package com.example.MyApp;
+
+import java.util.HashMap;
+import java.util.logging.Logger;
+
+// Simpler form of smoke test, but with a non-default package.
+public class AppFunctions {
+
+    // Logger for logging messages
+    private static final Logger logger = Logger.getLogger(TestFunctions.class.getName());
+
+    // Default constructor
+    public AppFunctions() {
+        logger.info("Constructor called");
+    }
+
+    // Method with no return type and no parameters
+    public void simpleMethod() {
+        logger.info("simpleMethod called");
+        methodWithParam(5); // Calling another method
+    }
+
+    // Method with a return type and one parameter
+    public int methodWithParam(int a) {
+        logger.info("methodWithParam(int a) called with a = " + a);
+        return a;
+    }
+
+    // Overloaded method with two parameters
+    public int methodWithParam(int a, int b) {
+        logger.info("methodWithParam(int a, int b) called with a = " + a + ", b = " + b);
+        staticMethod(); // Calling a static method
+        return a + b;
+    }
+
+    // Inner class with a constructor
+    class InnerClass {
+        public InnerClass() {
+            logger.info("InnerClass constructor called");
+        }
+    }
+
+    // Static inner class with a constructor
+    static class StaticInnerClass {
+        public StaticInnerClass() {
+            logger.info("StaticInnerClass constructor called");
+        }
+    }
+}
diff --git a/tests/it/main.rs b/tests/it/main.rs
index c2cb7c3..d4587c7 100644
--- a/tests/it/main.rs
+++ b/tests/it/main.rs
@@ -13,12 +13,15 @@
 //!
 /// [filtering events with environment variables]: https://docs.rs/tracing-subscriber/latest/tracing_subscriber/fmt/index.html#filtering-events-with-environment-variables
 pub mod language;
+pub mod parser;
+
 mod tracing;
 
 /// Include the contents of the file at the provided path, normalizing `\r\n` to `\n`.
 #[macro_export]
 macro_rules! include_str_lf {
-    ($path:expr) => {
-        include_str!($path).replace("\r\n", "\n")
-    };
+    ($path:expr) => {{
+        let content = include_str!($path).replace("\r\n", "\n");
+        snippets::content::Content::from(content)
+    }};
 }
diff --git a/tests/it/parser.rs b/tests/it/parser.rs
new file mode 100644
index 0000000..c93897d
--- /dev/null
+++ b/tests/it/parser.rs
@@ -0,0 +1 @@
+pub mod stack;
diff --git a/tests/it/parser/stack.rs b/tests/it/parser/stack.rs
new file mode 100644
index 0000000..5bb1f65
--- /dev/null
+++ b/tests/it/parser/stack.rs
@@ -0,0 +1,228 @@
+use itertools::Itertools;
+use pretty_assertions::assert_eq;
+
+use snippets::parser::{bytes::Location, stack::*, Symbol};
+
+/// Given some text, return a new location
+/// for that text that models it appearing
+/// immediately after the current content.
+macro_rules! stack_loc {
+    ($stack:ident, $text:expr) => {{
+        // Offset by one more byte; pretend this is a newline or space.
+        let byte_offset = $stack
+            .last()
+            .map(|e| e.location())
+            .unwrap_or_default()
+            .end_byte()
+            + 1;
+
+        Location::builder()
+            .byte_offset(byte_offset)
+            .byte_len($text.len())
+            .build()
+    }};
+}
+
+/// Push something on the stack.
+///
+/// Call with one of:
+/// - `stack => enter_scope`
+/// - `stack => exit_scope`
+/// - `stack => {symbol}`
+macro_rules! stack_push {
+    ($stack:ident => enter_scope) => {
+        $stack.enter(stack_loc!($stack, "{"))
+    };
+    ($stack:ident => exit_scope) => {
+        $stack.exit(stack_loc!($stack, "}"))
+    };
+    ($stack:ident => $symbol:expr) => {
+        $stack.push($symbol)
+    };
+}
+
+/// Make a new symbol for the stack.
+///
+/// Call with one of:
+/// - `stack => "name"`
+macro_rules! mk_symbol {
+    ($stack:ident => $name:expr) => {
+        Symbol::<String>::new($name, stack_loc!($stack, $name))
+    };
+}
+
+/// Assert the scope of the provided symbol.
+macro_rules! assert_scope {
+    ($stack:ident => $($scope:expr),* $(,)*) => {
+        assert_eq!($stack.retrace().collect_vec(), vec![$($scope,)*])
+    };
+    ($stack:ident, $symbol:expr => $($scope:expr),* $(,)*) => {
+        assert_eq!($stack.retrace_from($symbol).collect_vec(), vec![$($scope,)*])
+    };
+}
+
+#[test]
+fn smoke_scope() {
+    crate::tracing::setup();
+    let mut stack = Stack::default();
+
+    // Set the package at the base level.
+    // Note that it doesn't get a scope!
+    let package = mk_symbol!(stack => "com.example.myapp");
+    stack_push!(stack => &package);
+
+    // Now we've come across the declaration for `SomeClass`...
+    let some_class = mk_symbol!(stack => "SomeClass");
+    stack_push!(stack => &some_class);
+    stack_push!(stack => enter_scope);
+
+    // Oh look, it has a method inside!
+    let some_method = mk_symbol!(stack => "some_method");
+    stack_push!(stack => &some_method);
+    stack_push!(stack => enter_scope);
+
+    // Now we've found another class declaration inside that method...
+    let inner_class = mk_symbol!(stack => "InnerClass");
+    stack_push!(stack => &inner_class);
+    stack_push!(stack => enter_scope);
+
+    // ... and a method inside that class too...
+    let inner_method = mk_symbol!(stack => "inner_method");
+    stack_push!(stack => &inner_method);
+    stack_push!(stack => enter_scope);
+
+    // Next, declare some variables to make sure they don't mess with
+    // the scope parents incorrectly.
+    let logger_var = mk_symbol!(stack => "logger:Logger");
+    let today_var = mk_symbol!(stack => "today:Date");
+    stack_push!(stack => &logger_var);
+    stack_push!(stack => &today_var);
+
+    // Check the scope. Remember that scope is reported inverted from declaration order.
+    assert_scope!(
+        stack =>
+        &today_var,
+        &logger_var,
+        &inner_method,
+        &inner_class,
+        &some_method,
+        &some_class,
+        &package,
+    );
+
+    // Now let's pop the stack back up to just inside the `SomeClass` scope.
+    stack_push!(stack => exit_scope); // pop out of inner_method
+    stack_push!(stack => exit_scope); // pop out of InnerClass
+    stack_push!(stack => exit_scope); // pop out of some_method
+
+    // Remember that even though we've left the inner scope of `some_method`,
+    // `some_method` is still visible. We're now in the scope that contains it.
+    assert_scope!(
+        stack =>
+        &some_method,
+        &some_class,
+        &package,
+    );
+
+    // Now if we pop out of that to the base scope...
+    stack_push!(stack => exit_scope);
+    assert_scope!(
+        stack =>
+        &some_class,
+        &package,
+    );
+
+    // ... and enter a new class and method, does that look right?
+    // Note that `SomeClass` is a sibling of this class!
+    let other_class = mk_symbol!(stack => "OtherClass");
+    stack_push!(stack => &other_class);
+    stack_push!(stack => enter_scope);
+    assert_scope!(
+        stack =>
+        &other_class,
+        &some_class,
+        &package,
+    );
+
+    // Now, `OtherClass` has a constructor.
+    //
+    // Nothing else is declared inside it,
+    // so its scope is immediately pushed then popped.
+    //
+    // Note that this means the `other_constructor` symbol
+    // is left on the stack as a child of `other_class`.
+    let other_constructor = mk_symbol!(stack => "constructor");
+    stack_push!(stack => &other_constructor);
+    stack_push!(stack => enter_scope);
+    stack_push!(stack => exit_scope);
+
+    // And same deal with `other_method`.
+    let other_method = mk_symbol!(stack => "other_method");
+    stack_push!(stack => &other_method);
+    stack_push!(stack => enter_scope);
+    stack_push!(stack => exit_scope);
+
+    // How's the scope looking?
+    // Remember that we're still inside `OtherClass`'s scope,
+    // so the items in this scope should be visible.
+    assert_scope!(
+        stack =>
+        &other_method,
+        &other_constructor,
+        &other_class,
+        &some_class,
+        &package,
+    );
+
+    // Now, let's say we finish parsing the file...
+    stack_push!(stack => exit_scope); // pop out of `OtherClass`
+
+    // Can we still get the right scope for arbitrary symbols?
+    // Remember that the symbol doesn't appear in the stack reported for itself.
+    assert_scope!(
+        stack, &today_var =>
+        &logger_var,
+        &inner_method,
+        &inner_class,
+        &some_method,
+        &some_class,
+        &package,
+    );
+}
+
+#[test]
+fn retrace_from() {
+    crate::tracing::setup();
+    let mut stack = Stack::default();
+
+    // Set the package at the base level.
+    // Note that it doesn't get a scope!
+    let package = mk_symbol!(stack => "com.example.myapp");
+    stack_push!(stack => &package);
+
+    // Now we've come across the declaration for `SomeClass`...
+    let some_class = mk_symbol!(stack => "SomeClass");
+    stack_push!(stack => &some_class);
+    stack_push!(stack => enter_scope);
+    stack_push!(stack => exit_scope);
+
+    // And a sibling of it, `OtherClass`...
+    let other_class = mk_symbol!(stack => "OtherClass");
+    stack_push!(stack => &other_class);
+    stack_push!(stack => enter_scope);
+    stack_push!(stack => exit_scope);
+
+    // Make sure the scope is set up as intended:
+    assert_scope!(
+        stack =>
+        &other_class,
+        &some_class,
+        &package,
+    );
+
+    // Now, if we search for a symbol in the stack
+    // and retrace the scope from there, ensure:
+    // - It doesn't report things below it in the stack.
+    // - It doesn't report itself.
+    assert_scope!(stack, &some_class => &package);
+}