Review

app/gui/src/project-view/components/ComponentBrowser.vue

@@ -281,7 +281,7 @@ function applyComponent(component: Opt<Component> = null) {
     input.switchToCodeEditMode()
     return Ok()
   }
-  if (component.suggestionId) {
+  if (component.suggestionId != null) {
     return input.applySuggestion(component.suggestionId)
   } else {
     // Component without suggestion database entry, for example "literal" component.
@@ -297,16 +297,6 @@ function acceptComponent(component: Opt<Component> = null) {
   else result.error.log('Cannot apply suggestion')
 }
 
-// function editComponent(component: Opt<Component> = null) {
-//   const result = applyComponentToInput(component)
-//   if (result.ok) acceptInput()
-//   else result.error.log('Cannot apply suggestion')
-//   const suggestionId = component?.suggestionId ?? selectedSuggestionId.value
-//   if (suggestionId == null) return input.switchToCodeEditMode()
-//   const result = input.applySuggestion(suggestionId)
-//   if (!result.ok) result.error.log('Cannot apply suggestion')
-// }
-
 function acceptInput() {
   const appliedReturnType =
     input.mode.mode === 'codeEditing' ?

app/gui/src/project-view/components/ComponentBrowser/input.ts

@@ -32,7 +32,7 @@ export type ComponentBrowserMode =
   | {
       mode: 'componentBrowsing'
       filter: Filter
-      literal?: Ast.TextLiteral | Ast.NumericLiteral
+      literal?: Ast.TextLiteral | Ast.NumericLiteral | Ast.NegationApp | undefined
     }
   | {
       mode: 'codeEditing'
@@ -111,10 +111,10 @@ export function useComponentBrowserInput(
         : {}),
       }
     } else {
-      let literal: Ast.MutableTextLiteral | Ast.NumericLiteral | undefined =
+      let literal: Ast.MutableTextLiteral | Ast.NumericLiteral | Ast.NegationApp | undefined =
         Ast.TextLiteral.tryParse(text.value)
       if (literal == null) {
-        literal = Ast.NumericLiteral.tryParse(text.value)
+        literal = Ast.NumericLiteral.tryParseWithSign(text.value)
       } else {
         literal.fixBoundaries()
       }
@@ -124,7 +124,7 @@ export function useComponentBrowserInput(
           pattern: text.value,
           ...(sourceNodeType.value != null ? { selfArg: sourceNodeType.value } : {}),
         },
-        ...(literal ? { literal } : {}),
+        literal,
       }
     }
   })

app/gui/src/project-view/util/ast/__tests__/abstract.test.ts

@@ -1092,6 +1092,20 @@ test('setRawTextContent promotes single-line uninterpolated text to interpolated
   expect(literal.code()).toBe(`'${escapeTextLiteral(rawText)}'`)
 })
 
+test.each`
+  text               | fixed
+  ${"'abc'"}         | ${"'abc'"}
+  ${'"abc"'}         | ${'"abc"'}
+  ${"'''abc\n  cde"} | ${"'''abc\n  cde"}
+  ${"'abc"}          | ${"'abc'"}
+  ${'"abc'}          | ${'"abc"'}
+`('Fixing boundaries in $text', ({ text, fixed }) => {
+  const literal = Ast.TextLiteral.tryParse(text)
+  assert(literal != null)
+  literal.fixBoundaries()
+  expect(literal.code()).toBe(fixed)
+})
+
 test.each([
   { code: 'operator1', expected: { subject: 'operator1', accesses: [] } },
   { code: 'operator1 foo bar', expected: { subject: 'operator1 foo bar', accesses: [] } },

app/rust-ffi/src/lib.rs

@@ -26,14 +26,14 @@ pub fn parse_block(code: &str) -> Vec<u8> {
     enso_parser::format::serialize(&ast).expect("Failed to serialize AST to binary format")
 }
 
-#[wasm_bindgen]
-pub fn is_ident_or_operator(code: &str) -> u32 {
+fn starts_with_ident_or_operator<const ONLY_ONE_TOKEN_ALLOWED: bool>(code: &str) -> u32 {
     let parsed = enso_parser::lexer::run(code);
     if parsed.internal_error.is_some() {
         return 0;
     }
     let token = match &parsed.value[..] {
         [token] => token,
+        [token, ..] if !ONLY_ONE_TOKEN_ALLOWED => token,
         _ => return 0,
     };
     match &token.variant {
@@ -43,6 +43,17 @@ pub fn is_ident_or_operator(code: &str) -> u32 {
     }
 }
 
+#[wasm_bindgen]
+pub fn is_ident_or_operator(code: &str) -> u32 {
+    starts_with_ident_or_operator::<true>(code)
+}
+
+#[wasm_bindgen]
+pub fn is_first_token_ident_or_operator(code: &str) -> u32 {
+    starts_with_ident_or_operator::<false>(code)
+}
+
+
 #[wasm_bindgen]
 pub fn is_numeric_literal(code: &str) -> bool {
     let parsed = PARSER.with(|parser| parser.parse_block(code));
@@ -83,4 +94,20 @@ mod tests {
         assert!(!is_numeric_literal("1234!"));
         assert!(!is_numeric_literal("1234e5"));
     }
+
+    #[test]
+    fn test_checking_ident_or_operator() {
+        assert_eq!(is_ident_or_operator("abc"), 1);
+        assert_eq!(is_ident_or_operator("Abc"), 1);
+        assert_eq!(is_ident_or_operator("abc 14"), 0);
+        assert_eq!(is_ident_or_operator("+"), 2);
+        assert_eq!(is_ident_or_operator("+ 2"), 0);
+        assert_eq!(is_ident_or_operator("[]"), 0);
+
+        assert_eq!(is_first_token_ident_or_operator("abc"), 1);
+        assert_eq!(is_first_token_ident_or_operator("abc 14"), 1);
+        assert_eq!(is_first_token_ident_or_operator("+"), 2);
+        assert_eq!(is_first_token_ident_or_operator("+ 2"), 2);
+        assert_eq!(is_first_token_ident_or_operator("[]"), 0);
+    }
 }

app/ydoc-shared/src/ast/ffi.ts

@@ -6,6 +6,7 @@
 import { createXXHash128 } from 'hash-wasm'
 import type { IDataType } from 'hash-wasm/dist/lib/util'
 import {
+  is_first_token_ident_or_operator,
   is_ident_or_operator,
   is_numeric_literal,
   parse_block,
@@ -21,5 +22,12 @@ export function xxHash128(input: IDataType) {
   return xxHasher128.digest()
 }
 
-/* eslint-disable-next-line camelcase */
-export { is_ident_or_operator, is_numeric_literal, parse_block, parse_doc_to_json, parse_module }
+/* eslint-disable camelcase */
+export {
+  is_first_token_ident_or_operator,
+  is_ident_or_operator,
+  is_numeric_literal,
+  parse_block,
+  parse_doc_to_json,
+  parse_module,
+}

app/ydoc-shared/src/ast/token.ts

@@ -135,6 +135,8 @@ export function isIdentifier(code: string): code is Identifier {
   return is_ident_or_operator(code) === 1
 }
 
+export function startsWithIdentifier
+
 /**
  * Whether the given code is a type or constructor identifier.
  * This is true if the code is an identifier beginning with an uppercase letter.

app/ydoc-shared/src/ast/tree.ts

@@ -1890,13 +1890,17 @@ export class MutableTextLiteral extends TextLiteral implements MutableExpression
 
   setBoundaries(code: string) {
     this.fields.set('open', unspaced(Token.new(code)))
-    this.fields.set('close', unspaced(Token.new(code)))
+    if (code.length > 1) {
+      this.fields.set('close', undefined)
+    } else {
+      this.fields.set('close', unspaced(Token.new(code)))
+    }
   }
 
   fixBoundaries() {
     const open = this.open
     const close = this.close
-    if (open != null && close == null) {
+    if (open != null && close == null && open.code().length === 1) {
       this.fields.set('close', unspaced(Token.new(open.code())))
     } else if (open == null && close != null) {
       this.fields.set('open', unspaced(Token.new(close.code())))