From a6146d35b1615cf5fb908b29f34e58bfde3bf96d Mon Sep 17 00:00:00 2001
From: Marcus Klaas de Vries <mail@marcusklaas.nl>
Date: Thu, 10 Jan 2019 13:54:58 +0100
Subject: Implement type inference for literals (WIP)

---
 crates/ra_syntax/src/lib.rs                |  5 +++++
 crates/ra_syntax/src/yellow.rs             | 12 ++++++++++++
 crates/ra_syntax/src/yellow/syntax_text.rs | 11 ++++++++++-
 3 files changed, 27 insertions(+), 1 deletion(-)

(limited to 'crates/ra_syntax')

diff --git a/crates/ra_syntax/src/lib.rs b/crates/ra_syntax/src/lib.rs
index 2a095817a..6181df9d7 100644
--- a/crates/ra_syntax/src/lib.rs
+++ b/crates/ra_syntax/src/lib.rs
@@ -59,24 +59,29 @@ impl SourceFile {
         assert_eq!(root.kind(), SyntaxKind::SOURCE_FILE);
         TreeArc::cast(root)
     }
+    
     pub fn parse(text: &str) -> TreeArc<SourceFile> {
         let tokens = tokenize(&text);
         let (green, errors) =
             parser_impl::parse_with(yellow::GreenBuilder::new(), text, &tokens, grammar::root);
         SourceFile::new(green, errors)
     }
+
     pub fn reparse(&self, edit: &AtomTextEdit) -> TreeArc<SourceFile> {
         self.incremental_reparse(edit)
             .unwrap_or_else(|| self.full_reparse(edit))
     }
+
     pub fn incremental_reparse(&self, edit: &AtomTextEdit) -> Option<TreeArc<SourceFile>> {
         reparsing::incremental_reparse(self.syntax(), edit, self.errors())
             .map(|(green_node, errors)| SourceFile::new(green_node, errors))
     }
+
     fn full_reparse(&self, edit: &AtomTextEdit) -> TreeArc<SourceFile> {
         let text = edit.apply(self.syntax().text().to_string());
         SourceFile::parse(&text)
     }
+
     pub fn errors(&self) -> Vec<SyntaxError> {
         let mut errors = self.syntax.root_data().clone();
         errors.extend(validation::validate(self));
diff --git a/crates/ra_syntax/src/yellow.rs b/crates/ra_syntax/src/yellow.rs
index 93621d08a..03df00fc6 100644
--- a/crates/ra_syntax/src/yellow.rs
+++ b/crates/ra_syntax/src/yellow.rs
@@ -128,40 +128,52 @@ impl SyntaxNode {
     pub(crate) fn root_data(&self) -> &Vec<SyntaxError> {
         self.0.root_data()
     }
+    
     pub(crate) fn replace_with(&self, replacement: GreenNode) -> GreenNode {
         self.0.replace_self(replacement)
     }
+
     pub fn to_owned(&self) -> TreeArc<SyntaxNode> {
         let ptr = TreeArc(self.0.to_owned());
         TreeArc::cast(ptr)
     }
+
     pub fn kind(&self) -> SyntaxKind {
         self.0.kind()
     }
+
     pub fn range(&self) -> TextRange {
         self.0.range()
     }
+
     pub fn text(&self) -> SyntaxText {
         SyntaxText::new(self)
     }
+
     pub fn is_leaf(&self) -> bool {
         self.0.is_leaf()
     }
+
     pub fn parent(&self) -> Option<&SyntaxNode> {
         self.0.parent().map(SyntaxNode::from_repr)
     }
+
     pub fn first_child(&self) -> Option<&SyntaxNode> {
         self.0.first_child().map(SyntaxNode::from_repr)
     }
+
     pub fn last_child(&self) -> Option<&SyntaxNode> {
         self.0.last_child().map(SyntaxNode::from_repr)
     }
+
     pub fn next_sibling(&self) -> Option<&SyntaxNode> {
         self.0.next_sibling().map(SyntaxNode::from_repr)
     }
+
     pub fn prev_sibling(&self) -> Option<&SyntaxNode> {
         self.0.prev_sibling().map(SyntaxNode::from_repr)
     }
+
     pub fn children(&self) -> SyntaxNodeChildren {
         SyntaxNodeChildren(self.0.children())
     }
diff --git a/crates/ra_syntax/src/yellow/syntax_text.rs b/crates/ra_syntax/src/yellow/syntax_text.rs
index 08dbe57a2..378cd1b2e 100644
--- a/crates/ra_syntax/src/yellow/syntax_text.rs
+++ b/crates/ra_syntax/src/yellow/syntax_text.rs
@@ -15,6 +15,7 @@ impl<'a> SyntaxText<'a> {
             range: node.range(),
         }
     }
+
     pub fn chunks(&self) -> impl Iterator<Item = &'a str> {
         let range = self.range;
         self.node.descendants().filter_map(move |node| {
@@ -24,15 +25,19 @@ impl<'a> SyntaxText<'a> {
             Some(&text[range])
         })
     }
+
     pub fn push_to(&self, buf: &mut String) {
         self.chunks().for_each(|it| buf.push_str(it));
     }
+
     pub fn to_string(&self) -> String {
         self.chunks().collect()
     }
+
     pub fn contains(&self, c: char) -> bool {
         self.chunks().any(|it| it.contains(c))
     }
+
     pub fn find(&self, c: char) -> Option<TextUnit> {
         let mut acc: TextUnit = 0.into();
         for chunk in self.chunks() {
@@ -44,9 +49,11 @@ impl<'a> SyntaxText<'a> {
         }
         None
     }
+
     pub fn len(&self) -> TextUnit {
         self.range.len()
     }
+
     pub fn slice(&self, range: impl SyntaxTextSlice) -> SyntaxText<'a> {
         let range = range.restrict(self.range).unwrap_or_else(|| {
             panic!("invalid slice, range: {:?}, slice: {:?}", self.range, range)
@@ -56,8 +63,10 @@ impl<'a> SyntaxText<'a> {
             range,
         }
     }
-    pub fn char_at(&self, offset: TextUnit) -> Option<char> {
+
+    pub fn char_at(&self, offset: impl Into<TextUnit>) -> Option<char> {
         let mut start: TextUnit = 0.into();
+        let offset = offset.into();
         for chunk in self.chunks() {
             let end = start + TextUnit::of_str(chunk);
             if start <= offset && offset < end {
-- 
cgit v1.2.3