Address comments

harupy · harupy · commit c640312051f9 · 2023-01-05T18:24:54.000+09:00
diff --git a/compiler/parser/src/lexer.rs b/compiler/parser/src/lexer.rs
@@ -244,12 +244,12 @@ where
         // Detect potential string like rb'' b'' f'' u'' r''
         match self.window[..3] {
             [Some(c), Some('"' | '\''), ..] => {
-                if let Ok(kind) = StringKind::try_from(c.to_string()) {
+                if let Ok(kind) = StringKind::try_from(c) {
                     return self.lex_string(kind);
                 }
             }
             [Some(c1), Some(c2), Some('"' | '\'')] => {
-                if let Ok(kind) = StringKind::try_from(format!("{c1}{c2}")) {
+                if let Ok(kind) = StringKind::try_from([c1, c2]) {
                     return self.lex_string(kind);
                 }
             }
@@ -459,7 +459,7 @@ where
 
     fn lex_string(&mut self, kind: StringKind) -> LexResult {
         let start_pos = self.get_pos();
-        for _ in 0..kind.to_string().len() {
+        for _ in 0..kind.prefix_len() {
             self.next_char();
         }
         let quote_char = self.next_char().unwrap();
diff --git a/compiler/parser/src/string_parser.rs b/compiler/parser/src/string_parser.rs
@@ -26,7 +26,7 @@ impl<'a> StringParser<'a> {
         str_start: Location,
         str_end: Location,
     ) -> Self {
-        let offset = kind.to_string().len() + if triple_quoted { 3 } else { 1 };
+        let offset = kind.prefix_len() + if triple_quoted { 3 } else { 1 };
         Self {
             chars: source.chars().peekable(),
             kind,
diff --git a/compiler/parser/src/token.rs b/compiler/parser/src/token.rs
@@ -240,19 +240,30 @@ pub enum StringKind {
     Unicode,
 }
 
-impl TryFrom<String> for StringKind {
+impl TryFrom<char> for StringKind {
     type Error = String;
 
-    fn try_from(value: String) -> Result<Self, String> {
-        match value.as_str() {
-            "" => Ok(StringKind::String),
-            "r" | "R" => Ok(StringKind::RawString),
-            "u" | "U" => Ok(StringKind::Unicode),
-            "b" | "B" => Ok(StringKind::Bytes),
-            "f" | "F" => Ok(StringKind::FString),
-            "fr" | "Fr" | "fR" | "FR" | "rf" | "rF" | "Rf" | "RF" => Ok(StringKind::RawFString),
-            "br" | "Br" | "bR" | "BR" | "rb" | "rB" | "Rb" | "RB" => Ok(StringKind::RawBytes),
-            s => Err(format!("Unexpected string prefix: {s}")),
+    fn try_from(ch: char) -> Result<Self, String> {
+        match ch {
+            'r' | 'R' => Ok(StringKind::RawString),
+            'f' | 'F' => Ok(StringKind::FString),
+            'u' | 'U' => Ok(StringKind::Unicode),
+            'b' | 'B' => Ok(StringKind::Bytes),
+            c => Err(format!("Unexpected string prefix: {c}")),
+        }
+    }
+}
+
+impl TryFrom<[char; 2]> for StringKind {
+    type Error = String;
+
+    fn try_from(chars: [char; 2]) -> Result<Self, String> {
+        match chars {
+            ['r' | 'R', 'f' | 'F'] => Ok(StringKind::RawFString),
+            ['f' | 'F', 'r' | 'R'] => Ok(StringKind::RawFString),
+            ['r' | 'R', 'b' | 'B'] => Ok(StringKind::RawBytes),
+            ['b' | 'B', 'r' | 'R'] => Ok(StringKind::RawBytes),
+            [c1, c2] => Err(format!("Unexpected string prefix: {c1}{c2}")),
         }
     }
 }
@@ -291,4 +302,13 @@ impl StringKind {
     pub fn is_unicode(&self) -> bool {
         matches!(self, StringKind::Unicode)
     }
+
+    pub fn prefix_len(&self) -> usize {
+        use StringKind::*;
+        match self {
+            String => 0,
+            RawString | FString | Unicode | Bytes => 1,
+            RawFString | RawBytes => 2,
+        }
+    }
 }

Original file line number	Diff line number	Diff line change
`@@ -244,12 +244,12 @@ where`
`244`	`244`	`// Detect potential string like rb'' b'' f'' u'' r''`
`245`	`245`	`match self.window[..3] {`
`246`	`246`	`[Some(c), Some('"' \| '\''), ..] => {`
`247`		`- if let Ok(kind) = StringKind::try_from(c.to_string()) {`
	`247`	`+ if let Ok(kind) = StringKind::try_from(c) {`
`248`	`248`	`return self.lex_string(kind);`
`249`	`249`	`}`
`250`	`250`	`}`
`251`	`251`	`[Some(c1), Some(c2), Some('"' \| '\'')] => {`
`252`		`- if let Ok(kind) = StringKind::try_from(format!("{c1}{c2}")) {`
	`252`	`+ if let Ok(kind) = StringKind::try_from([c1, c2]) {`
`253`	`253`	`return self.lex_string(kind);`
`254`	`254`	`}`
`255`	`255`	`}`
`@@ -459,7 +459,7 @@ where`
`459`	`459`
`460`	`460`	`fn lex_string(&mut self, kind: StringKind) -> LexResult {`
`461`	`461`	`let start_pos = self.get_pos();`
`462`		`- for _ in 0..kind.to_string().len() {`
	`462`	`+ for _ in 0..kind.prefix_len() {`
`463`	`463`	`self.next_char();`
`464`	`464`	`}`
`465`	`465`	`let quote_char = self.next_char().unwrap();`