minor: tidy up Parse a little bit

DropDemBits · DropDemBits · commit becd71f826f6 · 2024-06-02T11:10:39.000-04:00
- Add doc comments to some `Parse` methods
- Uses `Parse::new` more
diff --git a/src/tools/rust-analyzer/crates/syntax/src/lib.rs b/src/tools/rust-analyzer/crates/syntax/src/lib.rs
@@ -107,14 +107,22 @@ impl<T> Parse<T> {
 }
 
 impl<T: AstNode> Parse<T> {
+    /// Converts this parse result into a parse result for an untyped syntax tree.
     pub fn to_syntax(self) -> Parse<SyntaxNode> {
         Parse { green: self.green, errors: self.errors, _ty: PhantomData }
     }
 
+    /// Gets the parsed syntax tree as a typed ast node.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the root node cannot be casted into the typed ast node
+    /// (e.g. if it's an `ERROR` node).
     pub fn tree(&self) -> T {
         T::cast(self.syntax_node()).unwrap()
     }
 
+    /// Converts from `Parse<T>` to [`Result<T, Vec<SyntaxError>>`].
     pub fn ok(self) -> Result<T, Vec<SyntaxError>> {
         match self.errors() {
             errors if !errors.is_empty() => Err(errors),
@@ -177,11 +185,7 @@ impl SourceFile {
         let root = SyntaxNode::new_root(green.clone());
 
         assert_eq!(root.kind(), SyntaxKind::SOURCE_FILE);
-        Parse {
-            green,
-            errors: if errors.is_empty() { None } else { Some(errors.into()) },
-            _ty: PhantomData,
-        }
+        Parse::new(green, errors)
     }
 }
 
@@ -290,12 +294,7 @@ impl ast::TokenTree {
         }
 
         let (green, errors) = builder.finish_raw();
-
-        Parse {
-            green,
-            errors: if errors.is_empty() { None } else { Some(errors.into()) },
-            _ty: PhantomData,
-        }
+        Parse::new(green, errors)
     }
 }
 

Original file line number	Diff line number	Diff line change
`@@ -107,14 +107,22 @@ impl<T> Parse<T> {`
`107`	`107`	`}`
`108`	`108`
`109`	`109`	`impl<T: AstNode> Parse<T> {`
	`110`	`+ /// Converts this parse result into a parse result for an untyped syntax tree.`
`110`	`111`	`pub fn to_syntax(self) -> Parse<SyntaxNode> {`
`111`	`112`	`Parse { green: self.green, errors: self.errors, _ty: PhantomData }`
`112`	`113`	`}`
`113`	`114`
	`115`	`+ /// Gets the parsed syntax tree as a typed ast node.`
	`116`	`+ ///`
	`117`	`+ /// # Panics`
	`118`	`+ ///`
	`119`	`+ /// Panics if the root node cannot be casted into the typed ast node`
	`120`	+ /// (e.g. if it's an `ERROR` node).
`114`	`121`	`pub fn tree(&self) -> T {`
`115`	`122`	`T::cast(self.syntax_node()).unwrap()`
`116`	`123`	`}`
`117`	`124`
	`125`	+ /// Converts from `Parse<T>` to [`Result<T, Vec<SyntaxError>>`].
`118`	`126`	`pub fn ok(self) -> Result<T, Vec<SyntaxError>> {`
`119`	`127`	`match self.errors() {`
`120`	`128`	`errors if !errors.is_empty() => Err(errors),`
`@@ -177,11 +185,7 @@ impl SourceFile {`
`177`	`185`	`let root = SyntaxNode::new_root(green.clone());`
`178`	`186`
`179`	`187`	`assert_eq!(root.kind(), SyntaxKind::SOURCE_FILE);`
`180`		`- Parse {`
`181`		`- green,`
`182`		`- errors: if errors.is_empty() { None } else { Some(errors.into()) },`
`183`		`- _ty: PhantomData,`
`184`		`- }`
	`188`	`+ Parse::new(green, errors)`
`185`	`189`	`}`
`186`	`190`	`}`
`187`	`191`
`@@ -290,12 +294,7 @@ impl ast::TokenTree {`
`290`	`294`	`}`
`291`	`295`
`292`	`296`	`let (green, errors) = builder.finish_raw();`
`293`		`-`
`294`		`- Parse {`
`295`		`- green,`
`296`		`- errors: if errors.is_empty() { None } else { Some(errors.into()) },`
`297`		`- _ty: PhantomData,`
`298`		`- }`
	`297`	`+ Parse::new(green, errors)`
`299`	`298`	`}`
`300`	`299`	`}`
`301`	`300`