Merge pull request #479 from Kmeakin/no-self

brendanzab · web-flow · commit 297d81d5a984 · 2023-01-31T10:39:09.000+11:00
Use explicit type names in place of `Self` where possible
diff --git a/fathom/src/alloc.rs b/fathom/src/alloc.rs
@@ -91,7 +91,7 @@ impl<'a, Elem> Deref for SliceVec<'a, Elem> {
 }
 
 impl<'a, Elem> From<SliceVec<'a, Elem>> for &'a [Elem] {
-    fn from(slice: SliceVec<'a, Elem>) -> Self {
+    fn from(slice: SliceVec<'a, Elem>) -> &'a [Elem] {
         // SAFETY: This is safe because we know that `self.elems[..self.next_index]`
         // only ever contains elements initialized with `MaybeUninit::new`.
         // We know this because:
diff --git a/fathom/src/core.rs b/fathom/src/core.rs
@@ -600,7 +600,7 @@ pub enum Const {
 }
 
 impl PartialEq for Const {
-    fn eq(&self, other: &Self) -> bool {
+    fn eq(&self, other: &Const) -> bool {
         match (*self, *other) {
             (Const::Bool(a), Const::Bool(b)) => a == b,
             (Const::U8(a, _), Const::U8(b, _)) => a == b,
@@ -623,13 +623,13 @@ impl PartialEq for Const {
 impl Eq for Const {}
 
 impl PartialOrd for Const {
-    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+    fn partial_cmp(&self, other: &Const) -> Option<std::cmp::Ordering> {
         Some(self.cmp(other))
     }
 }
 
 impl Ord for Const {
-    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+    fn cmp(&self, other: &Const) -> std::cmp::Ordering {
         match (*self, *other) {
             (Const::Bool(a), Const::Bool(b)) => a.cmp(&b),
             (Const::U8(a, _), Const::U8(b, _)) => a.cmp(&b),
diff --git a/fathom/src/core/binary.rs b/fathom/src/core/binary.rs
@@ -40,7 +40,7 @@ impl<'arena> fmt::Display for ReadError<'arena> {
 impl<'arena> std::error::Error for ReadError<'arena> {}
 
 impl<'arena> From<BufferError> for ReadError<'arena> {
-    fn from(err: BufferError) -> Self {
+    fn from(err: BufferError) -> ReadError<'arena> {
         ReadError::BufferError(Span::Empty, err)
     }
 }
diff --git a/fathom/src/files.rs b/fathom/src/files.rs
@@ -2,7 +2,7 @@
 //! `FileId` as the file id, instead of `usize`.
 
 use std::fmt;
-use std::num::NonZeroU32;
+use std::num::{NonZeroU32, TryFromIntError};
 use std::ops::Range;
 
 use codespan_reporting::files::{Error, SimpleFile};
@@ -21,28 +21,28 @@ impl fmt::Display for FileId {
 }
 
 impl TryFrom<u32> for FileId {
-    type Error = <NonZeroU32 as TryFrom<u32>>::Error;
+    type Error = TryFromIntError;
 
-    fn try_from(value: u32) -> Result<Self, Self::Error> {
+    fn try_from(value: u32) -> Result<FileId, TryFromIntError> {
         let id = NonZeroU32::try_from(value)?;
-        Ok(Self(id))
+        Ok(FileId(id))
     }
 }
 
 impl From<FileId> for NonZeroU32 {
-    fn from(value: FileId) -> Self {
+    fn from(value: FileId) -> NonZeroU32 {
         value.0
     }
 }
 
 impl From<FileId> for u32 {
-    fn from(value: FileId) -> Self {
+    fn from(value: FileId) -> u32 {
         value.0.get()
     }
 }
 
 impl From<FileId> for usize {
-    fn from(value: FileId) -> Self {
+    fn from(value: FileId) -> usize {
         value.0.get() as usize
     }
 }
diff --git a/fathom/src/source.rs b/fathom/src/source.rs
@@ -12,25 +12,24 @@ pub type StringId = string_interner::symbol::SymbolU32;
 pub struct StringInterner {
     alphabetic_names: Vec<StringId>,
     tuple_labels: Vec<StringId>,
-    strings: string_interner::StringInterner<
-        string_interner::backend::BucketBackend<StringId>,
-        std::hash::BuildHasherDefault<fxhash::FxHasher32>,
-    >,
+    strings: Strings,
 }
 
+type Strings = string_interner::StringInterner<
+    string_interner::backend::BucketBackend<StringId>,
+    std::hash::BuildHasherDefault<fxhash::FxHasher32>,
+>;
+
 impl Deref for StringInterner {
-    type Target = string_interner::StringInterner<
-        string_interner::backend::BucketBackend<StringId>,
-        std::hash::BuildHasherDefault<fxhash::FxHasher32>,
-    >;
+    type Target = Strings;
 
-    fn deref(&self) -> &Self::Target {
+    fn deref(&self) -> &Strings {
         &self.strings
     }
 }
 
 impl DerefMut for StringInterner {
-    fn deref_mut(&mut self) -> &mut Self::Target {
+    fn deref_mut(&mut self) -> &mut Strings {
         &mut self.strings
     }
 }
@@ -152,11 +151,11 @@ pub struct Spanned<T> {
 }
 
 impl<T> Spanned<T> {
-    pub fn new(span: Span, inner: T) -> Self {
+    pub fn new(span: Span, inner: T) -> Spanned<T> {
         Spanned { span, inner }
     }
 
-    pub fn empty(inner: T) -> Self {
+    pub fn empty(inner: T) -> Spanned<T> {
         Spanned {
             span: Span::Empty,
             inner,
@@ -184,13 +183,13 @@ impl<T> Spanned<T> {
 impl<T> Deref for Spanned<T> {
     type Target = T;
 
-    fn deref(&self) -> &Self::Target {
+    fn deref(&self) -> &T {
         &self.inner
     }
 }
 
 impl<T> DerefMut for Spanned<T> {
-    fn deref_mut(&mut self) -> &mut Self::Target {
+    fn deref_mut(&mut self) -> &mut T {
         &mut self.inner
     }
 }
@@ -211,13 +210,13 @@ impl Span {
 }
 
 impl From<FileRange> for Span {
-    fn from(range: FileRange) -> Self {
+    fn from(range: FileRange) -> Span {
         Span::Range(range)
     }
 }
 
 impl From<&FileRange> for Span {
-    fn from(range: &FileRange) -> Self {
+    fn from(range: &FileRange) -> Span {
         Span::Range(*range)
     }
 }
@@ -285,7 +284,7 @@ impl FileRange {
 }
 
 impl From<FileRange> for Range<usize> {
-    fn from(file_range: FileRange) -> Self {
+    fn from(file_range: FileRange) -> Range<usize> {
         file_range.byte_range.into()
     }
 }
@@ -303,8 +302,8 @@ impl fmt::Debug for ByteRange {
 }
 
 impl ByteRange {
-    pub fn new(start: BytePos, end: BytePos) -> Self {
-        Self { start, end }
+    pub fn new(start: BytePos, end: BytePos) -> ByteRange {
+        ByteRange { start, end }
     }
 
     pub const fn start(&self) -> BytePos {
@@ -315,13 +314,13 @@ impl ByteRange {
         self.end
     }
 
-    pub fn merge(self, other: Self) -> Self {
-        Self::new(self.start.min(other.start), self.end.max(other.end))
+    pub fn merge(self, other: ByteRange) -> ByteRange {
+        ByteRange::new(self.start.min(other.start), self.end.max(other.end))
     }
 }
 
 impl From<ByteRange> for Range<usize> {
-    fn from(range: ByteRange) -> Self {
+    fn from(range: ByteRange) -> Range<usize> {
         (range.start as usize)..(range.end as usize)
     }
 }
@@ -342,7 +341,7 @@ impl fmt::Display for ProgramSource {
 impl Deref for ProgramSource {
     type Target = String;
 
-    fn deref(&self) -> &Self::Target {
+    fn deref(&self) -> &String {
         &self.0
     }
 }
@@ -354,7 +353,7 @@ impl AsRef<str> for ProgramSource {
 }
 
 impl From<ProgramSource> for String {
-    fn from(source: ProgramSource) -> Self {
+    fn from(source: ProgramSource) -> String {
         source.0
     }
 }
@@ -367,9 +366,9 @@ pub struct SourceTooBig {
 impl TryFrom<String> for ProgramSource {
     type Error = SourceTooBig;
 
-    fn try_from(string: String) -> Result<Self, Self::Error> {
+    fn try_from(string: String) -> Result<ProgramSource, SourceTooBig> {
         if string.len() <= MAX_SOURCE_LEN {
-            Ok(Self(string))
+            Ok(ProgramSource(string))
         } else {
             Err(SourceTooBig {
                 actual_len: string.len(),
diff --git a/fathom/src/surface/elaboration/order.rs b/fathom/src/surface/elaboration/order.rs
@@ -71,7 +71,9 @@ struct ModuleOrderContext<'a, 'interner, 'arena> {
 }
 
 impl<'a, 'interner, 'arena> ModuleOrderContext<'a, 'interner, 'arena> {
-    fn new(elab_context: &'a mut elaboration::Context<'interner, 'arena>) -> Self {
+    fn new(
+        elab_context: &'a mut elaboration::Context<'interner, 'arena>,
+    ) -> ModuleOrderContext<'a, 'interner, 'arena> {
         ModuleOrderContext {
             elab_context,
             output: Vec::new(),
diff --git a/fathom/src/surface/pretty.rs b/fathom/src/surface/pretty.rs
@@ -1,6 +1,6 @@
 use std::cell::RefCell;
 
-use pretty::{Doc, DocAllocator, DocBuilder, DocPtr, RefDoc};
+use pretty::{Doc, DocAllocator, DocPtr, RefDoc};
 use scoped_arena::Scope;
 
 use crate::source::{StringId, StringInterner};
@@ -9,6 +9,8 @@ use crate::surface::{Arg, FormatField, Item, Module, Param, Pattern, Plicity, Te
 
 const INDENT: isize = 4;
 
+type DocBuilder<'interner, 'arena> = pretty::DocBuilder<'arena, Context<'interner, 'arena>>;
+
 pub struct Context<'interner, 'arena> {
     interner: &'interner RefCell<StringInterner>,
     scope: &'arena Scope<'arena>,
@@ -22,29 +24,32 @@ impl<'interner, 'arena> Context<'interner, 'arena> {
         Context { interner, scope }
     }
 
-    fn string_id(&'arena self, name: StringId) -> DocBuilder<'arena, Self> {
+    fn string_id(&'arena self, name: StringId) -> DocBuilder<'interner, 'arena> {
         match self.interner.borrow().resolve(name) {
             Some(name) => self.text(name.to_owned()),
             None => self.text("#error"),
         }
     }
 
-    fn ident(&'arena self, name: StringId) -> DocBuilder<'arena, Self> {
+    fn ident(&'arena self, name: StringId) -> DocBuilder<'interner, 'arena> {
         match self.interner.borrow().resolve(name) {
             Some(name) if is_keyword(name) => self.text(format!("r#{name}")),
             Some(name) => self.text(name.to_owned()),
             None => self.text("#error"),
         }
     }
 
-    pub fn module<Range>(&'arena self, module: &Module<'_, Range>) -> DocBuilder<'arena, Self> {
+    pub fn module<Range>(
+        &'arena self,
+        module: &Module<'_, Range>,
+    ) -> DocBuilder<'interner, 'arena> {
         self.intersperse(
             module.items.iter().map(|item| self.item(item)),
             self.hardline(),
         )
     }
 
-    fn item<Range>(&'arena self, item: &Item<'_, Range>) -> DocBuilder<'arena, Self> {
+    fn item<Range>(&'arena self, item: &Item<'_, Range>) -> DocBuilder<'interner, 'arena> {
         match item {
             Item::Def(item) => self
                 .concat([
@@ -79,7 +84,7 @@ impl<'interner, 'arena> Context<'interner, 'arena> {
         }
     }
 
-    fn pattern<Range>(&'arena self, pattern: &Pattern<Range>) -> DocBuilder<'arena, Self> {
+    fn pattern<Range>(&'arena self, pattern: &Pattern<Range>) -> DocBuilder<'interner, 'arena> {
         match pattern {
             Pattern::Placeholder(_) => self.text("_"),
             Pattern::Name(_, name) => self.ident(*name),
@@ -92,7 +97,7 @@ impl<'interner, 'arena> Context<'interner, 'arena> {
         }
     }
 
-    fn plicity(&'arena self, plicity: Plicity) -> DocBuilder<'arena, Self> {
+    fn plicity(&'arena self, plicity: Plicity) -> DocBuilder<'interner, 'arena> {
         match plicity {
             Plicity::Explicit => self.nil(),
             Plicity::Implicit => self.text("@"),
@@ -103,7 +108,7 @@ impl<'interner, 'arena> Context<'interner, 'arena> {
         &'arena self,
         pattern: &Pattern<Range>,
         r#type: Option<&Term<'_, Range>>,
-    ) -> DocBuilder<'arena, Self> {
+    ) -> DocBuilder<'interner, 'arena> {
         match r#type {
             None => self.pattern(pattern),
             Some(r#type) => self.concat([
@@ -115,7 +120,7 @@ impl<'interner, 'arena> Context<'interner, 'arena> {
         }
     }
 
-    fn param<Range>(&'arena self, param: &Param<'_, Range>) -> DocBuilder<'arena, Self> {
+    fn param<Range>(&'arena self, param: &Param<'_, Range>) -> DocBuilder<'interner, 'arena> {
         match &param.r#type {
             None => self.concat([self.plicity(param.plicity), self.pattern(&param.pattern)]),
             Some(r#type) => self.concat([
@@ -134,15 +139,15 @@ impl<'interner, 'arena> Context<'interner, 'arena> {
         }
     }
 
-    fn params<Range>(&'arena self, params: &[Param<'_, Range>]) -> DocBuilder<'arena, Self> {
+    fn params<Range>(&'arena self, params: &[Param<'_, Range>]) -> DocBuilder<'interner, 'arena> {
         self.concat((params.iter()).map(|param| self.concat([self.space(), self.param(param)])))
     }
 
-    fn arg<Range>(&'arena self, arg: &Arg<'_, Range>) -> DocBuilder<'arena, Self> {
+    fn arg<Range>(&'arena self, arg: &Arg<'_, Range>) -> DocBuilder<'interner, 'arena> {
         self.concat([self.plicity(arg.plicity), self.term(&arg.term)])
     }
 
-    pub fn term<Range>(&'arena self, term: &Term<'_, Range>) -> DocBuilder<'arena, Self> {
+    pub fn term<Range>(&'arena self, term: &Term<'_, Range>) -> DocBuilder<'interner, 'arena> {
         // FIXME: indentation and grouping
 
         match term {
@@ -337,7 +342,7 @@ impl<'interner, 'arena> Context<'interner, 'arena> {
     fn format_field<Range>(
         &'arena self,
         format_field: &FormatField<'_, Range>,
-    ) -> DocBuilder<'arena, Self> {
+    ) -> DocBuilder<'interner, 'arena> {
         match format_field {
             FormatField::Format {
                 label,
@@ -385,7 +390,7 @@ impl<'interner, 'arena> Context<'interner, 'arena> {
     }
 
     /// Wrap a document in parens.
-    fn paren(&'arena self, doc: DocBuilder<'arena, Self>) -> DocBuilder<'arena, Self> {
+    fn paren(&'arena self, doc: DocBuilder<'interner, 'arena>) -> DocBuilder<'interner, 'arena> {
         self.concat([self.text("("), doc, self.text(")")])
     }
 
@@ -396,11 +401,11 @@ impl<'interner, 'arena> Context<'interner, 'arena> {
     pub fn sequence(
         &'arena self,
         space: bool,
-        start_delim: DocBuilder<'arena, Self>,
-        docs: impl ExactSizeIterator<Item = DocBuilder<'arena, Self>> + Clone,
-        separator: DocBuilder<'arena, Self>,
-        end_delim: DocBuilder<'arena, Self>,
-    ) -> DocBuilder<'arena, Self> {
+        start_delim: DocBuilder<'interner, 'arena>,
+        docs: impl ExactSizeIterator<Item = DocBuilder<'interner, 'arena>> + Clone,
+        separator: DocBuilder<'interner, 'arena>,
+        end_delim: DocBuilder<'interner, 'arena>,
+    ) -> DocBuilder<'interner, 'arena> {
         if docs.len() == 0 {
             return self.concat([start_delim, end_delim]);
         }
diff --git a/fathom/tests/source_tests.rs b/fathom/tests/source_tests.rs

Original file line number	Diff line number	Diff line change
`@@ -91,7 +91,7 @@ impl<'a, Elem> Deref for SliceVec<'a, Elem> {`
`91`	`91`	`}`
`92`	`92`
`93`	`93`	`impl<'a, Elem> From<SliceVec<'a, Elem>> for &'a [Elem] {`
`94`		`- fn from(slice: SliceVec<'a, Elem>) -> Self {`
	`94`	`+ fn from(slice: SliceVec<'a, Elem>) -> &'a [Elem] {`
`95`	`95`	// SAFETY: This is safe because we know that `self.elems[..self.next_index]`
`96`	`96`	// only ever contains elements initialized with `MaybeUninit::new`.
`97`	`97`	`// We know this because:`
Original file line number	Diff line number	Diff line change
`@@ -40,7 +40,7 @@ impl<'arena> fmt::Display for ReadError<'arena> {`
`40`	`40`	`impl<'arena> std::error::Error for ReadError<'arena> {}`
`41`	`41`
`42`	`42`	`impl<'arena> From<BufferError> for ReadError<'arena> {`
`43`		`- fn from(err: BufferError) -> Self {`
	`43`	`+ fn from(err: BufferError) -> ReadError<'arena> {`
`44`	`44`	`ReadError::BufferError(Span::Empty, err)`
`45`	`45`	`}`
`46`	`46`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2,7 +2,7 @@`
`2`	`2`	//! `FileId` as the file id, instead of `usize`.
`3`	`3`
`4`	`4`	`use std::fmt;`
`5`		`-use std::num::NonZeroU32;`
	`5`	`+use std::num::{NonZeroU32, TryFromIntError};`
`6`	`6`	`use std::ops::Range;`
`7`	`7`
`8`	`8`	`use codespan_reporting::files::{Error, SimpleFile};`
`@@ -21,28 +21,28 @@ impl fmt::Display for FileId {`
`21`	`21`	`}`
`22`	`22`
`23`	`23`	`impl TryFrom<u32> for FileId {`
`24`		`- type Error = <NonZeroU32 as TryFrom<u32>>::Error;`
	`24`	`+ type Error = TryFromIntError;`
`25`	`25`
`26`		`- fn try_from(value: u32) -> Result<Self, Self::Error> {`
	`26`	`+ fn try_from(value: u32) -> Result<FileId, TryFromIntError> {`
`27`	`27`	`let id = NonZeroU32::try_from(value)?;`
`28`		`- Ok(Self(id))`
	`28`	`+ Ok(FileId(id))`
`29`	`29`	`}`
`30`	`30`	`}`
`31`	`31`
`32`	`32`	`impl From<FileId> for NonZeroU32 {`
`33`		`- fn from(value: FileId) -> Self {`
	`33`	`+ fn from(value: FileId) -> NonZeroU32 {`
`34`	`34`	`value.0`
`35`	`35`	`}`
`36`	`36`	`}`
`37`	`37`
`38`	`38`	`impl From<FileId> for u32 {`
`39`		`- fn from(value: FileId) -> Self {`
	`39`	`+ fn from(value: FileId) -> u32 {`
`40`	`40`	`value.0.get()`
`41`	`41`	`}`
`42`	`42`	`}`
`43`	`43`
`44`	`44`	`impl From<FileId> for usize {`
`45`		`- fn from(value: FileId) -> Self {`
	`45`	`+ fn from(value: FileId) -> usize {`
`46`	`46`	`value.0.get() as usize`
`47`	`47`	`}`
`48`	`48`	`}`
Original file line number	Diff line number	Diff line change
`@@ -12,25 +12,24 @@ pub type StringId = string_interner::symbol::SymbolU32;`
`12`	`12`	`pub struct StringInterner {`
`13`	`13`	`alphabetic_names: Vec<StringId>,`
`14`	`14`	`tuple_labels: Vec<StringId>,`
`15`		`- strings: string_interner::StringInterner<`
`16`		`- string_interner::backend::BucketBackend<StringId>,`
`17`		`- std::hash::BuildHasherDefault<fxhash::FxHasher32>,`
`18`		`- >,`
	`15`	`+ strings: Strings,`
`19`	`16`	`}`
`20`	`17`
	`18`	`+type Strings = string_interner::StringInterner<`
	`19`	`+ string_interner::backend::BucketBackend<StringId>,`
	`20`	`+ std::hash::BuildHasherDefault<fxhash::FxHasher32>,`
	`21`	`+>;`
	`22`	`+`
`21`	`23`	`impl Deref for StringInterner {`
`22`		`- type Target = string_interner::StringInterner<`
`23`		`- string_interner::backend::BucketBackend<StringId>,`
`24`		`- std::hash::BuildHasherDefault<fxhash::FxHasher32>,`
`25`		`- >;`
	`24`	`+ type Target = Strings;`
`26`	`25`
`27`		`- fn deref(&self) -> &Self::Target {`
	`26`	`+ fn deref(&self) -> &Strings {`
`28`	`27`	`&self.strings`
`29`	`28`	`}`
`30`	`29`	`}`
`31`	`30`
`32`	`31`	`impl DerefMut for StringInterner {`
`33`		`- fn deref_mut(&mut self) -> &mut Self::Target {`
	`32`	`+ fn deref_mut(&mut self) -> &mut Strings {`
`34`	`33`	`&mut self.strings`
`35`	`34`	`}`
`36`	`35`	`}`
`@@ -152,11 +151,11 @@ pub struct Spanned<T> {`
`152`	`151`	`}`
`153`	`152`
`154`	`153`	`impl<T> Spanned<T> {`
`155`		`- pub fn new(span: Span, inner: T) -> Self {`
	`154`	`+ pub fn new(span: Span, inner: T) -> Spanned<T> {`
`156`	`155`	`Spanned { span, inner }`
`157`	`156`	`}`
`158`	`157`
`159`		`- pub fn empty(inner: T) -> Self {`
	`158`	`+ pub fn empty(inner: T) -> Spanned<T> {`
`160`	`159`	`Spanned {`
`161`	`160`	`span: Span::Empty,`
`162`	`161`	`inner,`
`@@ -184,13 +183,13 @@ impl<T> Spanned<T> {`
`184`	`183`	`impl<T> Deref for Spanned<T> {`
`185`	`184`	`type Target = T;`
`186`	`185`
`187`		`- fn deref(&self) -> &Self::Target {`
	`186`	`+ fn deref(&self) -> &T {`
`188`	`187`	`&self.inner`
`189`	`188`	`}`
`190`	`189`	`}`
`191`	`190`
`192`	`191`	`impl<T> DerefMut for Spanned<T> {`
`193`		`- fn deref_mut(&mut self) -> &mut Self::Target {`
	`192`	`+ fn deref_mut(&mut self) -> &mut T {`
`194`	`193`	`&mut self.inner`
`195`	`194`	`}`
`196`	`195`	`}`
`@@ -211,13 +210,13 @@ impl Span {`
`211`	`210`	`}`
`212`	`211`
`213`	`212`	`impl From<FileRange> for Span {`
`214`		`- fn from(range: FileRange) -> Self {`
	`213`	`+ fn from(range: FileRange) -> Span {`
`215`	`214`	`Span::Range(range)`
`216`	`215`	`}`
`217`	`216`	`}`
`218`	`217`
`219`	`218`	`impl From<&FileRange> for Span {`
`220`		`- fn from(range: &FileRange) -> Self {`
	`219`	`+ fn from(range: &FileRange) -> Span {`
`221`	`220`	`Span::Range(*range)`
`222`	`221`	`}`
`223`	`222`	`}`
`@@ -285,7 +284,7 @@ impl FileRange {`
`285`	`284`	`}`
`286`	`285`
`287`	`286`	`impl From<FileRange> for Range<usize> {`
`288`		`- fn from(file_range: FileRange) -> Self {`
	`287`	`+ fn from(file_range: FileRange) -> Range<usize> {`
`289`	`288`	`file_range.byte_range.into()`
`290`	`289`	`}`
`291`	`290`	`}`
`@@ -303,8 +302,8 @@ impl fmt::Debug for ByteRange {`
`303`	`302`	`}`
`304`	`303`
`305`	`304`	`impl ByteRange {`
`306`		`- pub fn new(start: BytePos, end: BytePos) -> Self {`
`307`		`- Self { start, end }`
	`305`	`+ pub fn new(start: BytePos, end: BytePos) -> ByteRange {`
	`306`	`+ ByteRange { start, end }`
`308`	`307`	`}`
`309`	`308`
`310`	`309`	`pub const fn start(&self) -> BytePos {`
`@@ -315,13 +314,13 @@ impl ByteRange {`
`315`	`314`	`self.end`
`316`	`315`	`}`
`317`	`316`
`318`		`- pub fn merge(self, other: Self) -> Self {`
`319`		`- Self::new(self.start.min(other.start), self.end.max(other.end))`
	`317`	`+ pub fn merge(self, other: ByteRange) -> ByteRange {`
	`318`	`+ ByteRange::new(self.start.min(other.start), self.end.max(other.end))`
`320`	`319`	`}`
`321`	`320`	`}`
`322`	`321`
`323`	`322`	`impl From<ByteRange> for Range<usize> {`
`324`		`- fn from(range: ByteRange) -> Self {`
	`323`	`+ fn from(range: ByteRange) -> Range<usize> {`
`325`	`324`	`(range.start as usize)..(range.end as usize)`
`326`	`325`	`}`
`327`	`326`	`}`
`@@ -342,7 +341,7 @@ impl fmt::Display for ProgramSource {`
`342`	`341`	`impl Deref for ProgramSource {`
`343`	`342`	`type Target = String;`
`344`	`343`
`345`		`- fn deref(&self) -> &Self::Target {`
	`344`	`+ fn deref(&self) -> &String {`
`346`	`345`	`&self.0`
`347`	`346`	`}`
`348`	`347`	`}`
`@@ -354,7 +353,7 @@ impl AsRef<str> for ProgramSource {`
`354`	`353`	`}`
`355`	`354`
`356`	`355`	`impl From<ProgramSource> for String {`
`357`		`- fn from(source: ProgramSource) -> Self {`
	`356`	`+ fn from(source: ProgramSource) -> String {`
`358`	`357`	`source.0`
`359`	`358`	`}`
`360`	`359`	`}`
`@@ -367,9 +366,9 @@ pub struct SourceTooBig {`
`367`	`366`	`impl TryFrom<String> for ProgramSource {`
`368`	`367`	`type Error = SourceTooBig;`
`369`	`368`
`370`		`- fn try_from(string: String) -> Result<Self, Self::Error> {`
	`369`	`+ fn try_from(string: String) -> Result<ProgramSource, SourceTooBig> {`
`371`	`370`	`if string.len() <= MAX_SOURCE_LEN {`
`372`		`- Ok(Self(string))`
	`371`	`+ Ok(ProgramSource(string))`
`373`	`372`	`} else {`
`374`	`373`	`Err(SourceTooBig {`
`375`	`374`	`actual_len: string.len(),`