Backticky symbol parsing

codebase2/codebase-sqlite-hashing-v2/src/U/Codebase/Decl/Hashing.hs

@@ -34,7 +34,7 @@ verifyDeclFormatHash (ComponentHash hash) (DeclFormat.Decl (DeclFormat.LocallyIn
     & Map.toList
     & fmap (\(_refId, (v, decl, ())) -> (v, either H2.toDataDecl id $ H2.v2ToH2Decl decl))
     & Map.fromList
-    & H2.hashDecls Name.unsafeFromVar
+    & H2.hashDecls Name.unsafeParseVar
     & \case
       Left _err -> Just HH.DeclHashResolutionFailure
       Right m ->

codebase2/codebase-sqlite/U/Codebase/Sqlite/Queries.hs

@@ -393,7 +393,7 @@ import Unison.Hash qualified as Hash
 import Unison.Hash32 (Hash32)
 import Unison.Hash32 qualified as Hash32
 import Unison.Hash32.Orphans.Sqlite ()
-import Unison.NameSegment (NameSegment)
+import Unison.NameSegment (NameSegment (NameSegment))
 import Unison.NameSegment qualified as NameSegment
 import Unison.Prelude
 import Unison.Sqlite
@@ -658,7 +658,7 @@ saveNameSegment =
 
 expectNameSegment :: TextId -> Transaction NameSegment
 expectNameSegment =
-  fmap NameSegment.unsafeFromUnescapedText . expectText
+  fmap NameSegment . expectText
 
 saveHashObject :: HashId -> ObjectId -> HashVersion -> Transaction ()
 saveHashObject hId oId version =
@@ -4243,7 +4243,7 @@ data JsonParseFailure = JsonParseFailure
   deriving anyclass (SqliteExceptionReason)
 
 -- | Get the most recent namespace the user has visited.
-expectMostRecentNamespace :: Transaction [Text]
+expectMostRecentNamespace :: Transaction [NameSegment]
 expectMostRecentNamespace =
   queryOneColCheck
     [sql|
@@ -4252,11 +4252,11 @@ expectMostRecentNamespace =
     |]
     check
   where
-    check :: Text -> Either JsonParseFailure [Text]
+    check :: Text -> Either JsonParseFailure [NameSegment]
     check bytes =
       case Aeson.eitherDecodeStrict (Text.encodeUtf8 bytes) of
         Left failure -> Left JsonParseFailure {bytes, failure = Text.pack failure}
-        Right namespace -> Right namespace
+        Right namespace -> Right (map NameSegment namespace)
 
 -- | Set the most recent namespace the user has visited.
 setMostRecentNamespace :: [Text] -> Transaction ()

codebase2/core/Unison/NameSegment.hs

@@ -1,77 +1,57 @@
-module Unison.NameSegment where
+module Unison.NameSegment
+  ( NameSegment (..),
+    toUnescapedText,
+    isPrefixOf,
+
+    -- * Sentinel name segments
+    defaultPatchSegment,
+    docSegment,
+    libSegment,
+  )
+where
 
 import Data.Text qualified as Text
-import Data.Text.Lazy.Builder qualified as Text (Builder)
-import Data.Text.Lazy.Builder qualified as Text.Builder
 import Unison.Prelude
 import Unison.Util.Alphabetical (Alphabetical)
 
 -- Represents the parts of a name between the `.`s
 newtype NameSegment
-  = UnsafeNameSegment Text
+  = NameSegment Text
   deriving stock (Eq, Ord, Generic)
   deriving newtype (Alphabetical)
 
-instance Show NameSegment where
-  show = show . toUnescapedText
+instance IsString NameSegment where
+  fromString =
+    NameSegment . Text.pack
 
--- | Convert a text to a name segment, when the text is known to be a valid name segment.
---
--- For example, to make a name segment containing the text ".~", use @unsafeFromUnescapedText ".~"@, even if that
--- operator would need to be escaped (e.g. "`.~`") when written by a user.
-unsafeFromUnescapedText :: Text -> NameSegment
-unsafeFromUnescapedText =
-  UnsafeNameSegment
+instance Show NameSegment where
+  show =
+    Text.unpack . toUnescapedText
 
 -- | Convert a name segment to unescaped text.
 --
+-- You might use this when storing a name segment as text in a database, where the literal name segment bytes are all
+-- that matter. However, you wouldn't use this to display the name segment to a user - that depends on concrete syntax.
+-- See Unison.Syntax.NameSegment (or indeed, some actual yet-built interface that abstracts concrete syntax) for that
+-- kind of function.
+--
 -- > toUnescapedText (unsafeFromText ".~") = ".~"
 toUnescapedText :: NameSegment -> Text
 toUnescapedText =
   coerce
 
--- Split text into segments. A smarter version of `Text.splitOn` that handles
--- the name `.` properly.
-segments' :: Text -> [Text]
-segments' n = go split
-  where
-    split = Text.splitOn "." n
-    go [] = []
-    go ("" : "" : z) = "." : go z
-    go ("" : z) = go z
-    go (x : y) = x : go y
-
--- Same as reverse . segments', but produces the output as a
--- lazy list, suitable for suffix-based ordering purposes or
--- building suffix tries. Examples:
---
---   reverseSegments' "foo.bar.baz"  => ["baz","bar","foo"]
---   reverseSegments' ".foo.bar.baz" => ["baz","bar","foo"]
---   reverseSegments' ".."           => ["."]
---   reverseSegments' "Nat.++"       => ["++","Nat"]
---   reverseSegments' "Nat.++.zoo"   => ["zoo","++","Nat"]
-reverseSegments' :: Text -> [Text]
-reverseSegments' = go
-  where
-    go "" = []
-    go t =
-      let seg0 = Text.takeWhileEnd (/= '.') t
-          seg = if Text.null seg0 then Text.takeEnd 1 t else seg0
-          rem = Text.dropEnd (Text.length seg + 1) t
-       in seg : go rem
-
-isEmpty :: NameSegment -> Bool
-isEmpty =
-  coerce Text.null
-
 isPrefixOf :: NameSegment -> NameSegment -> Bool
 isPrefixOf =
   coerce Text.isPrefixOf
 
-toTextBuilder :: NameSegment -> Text.Builder
-toTextBuilder =
-  coerce Text.Builder.fromText
+defaultPatchSegment :: NameSegment
+defaultPatchSegment =
+  "patch"
+
+docSegment :: NameSegment
+docSegment =
+  "doc"
 
 libSegment :: NameSegment
 libSegment =
-   unsafeFromUnescapedText "lib"
+  "lib"

parser-typechecker/src/Unison/Builtin.hs

@@ -38,7 +38,7 @@ import Unison.Prelude
 import Unison.Reference qualified as R
 import Unison.Referent qualified as Referent
 import Unison.Symbol (Symbol)
-import Unison.Syntax.Name qualified as Name (unsafeFromText, unsafeFromVar)
+import Unison.Syntax.Name qualified as Name (unsafeParseText, unsafeParseVar)
 import Unison.Type qualified as Type
 import Unison.Typechecker.TypeLookup qualified as TL
 import Unison.Util.Relation qualified as Rel
@@ -56,24 +56,24 @@ names = Names terms types
     terms =
       Rel.mapRan Referent.Ref (Rel.fromMap termNameRefs)
         <> Rel.fromList
-          [ (Name.unsafeFromVar vc, Referent.Con (ConstructorReference (R.DerivedId r) cid) ct)
+          [ (Name.unsafeParseVar vc, Referent.Con (ConstructorReference (R.DerivedId r) cid) ct)
             | (ct, (_, (r, decl))) <-
                 ((CT.Data,) <$> builtinDataDecls)
                   <> ((CT.Effect,) . (second . second) DD.toDataDecl <$> builtinEffectDecls),
               ((_, vc, _), cid) <- DD.constructors' decl `zip` [0 ..]
           ]
         <> Rel.fromList
-          [ (Name.unsafeFromVar v, Referent.Ref (R.DerivedId i))
+          [ (Name.unsafeParseVar v, Referent.Ref (R.DerivedId i))
             | (v, i) <- Map.toList TD.builtinTermsRef
           ]
     types =
       Rel.fromList builtinTypes
         <> Rel.fromList
-          [ (Name.unsafeFromVar v, R.DerivedId r)
+          [ (Name.unsafeParseVar v, R.DerivedId r)
             | (v, (r, _)) <- builtinDataDecls
           ]
         <> Rel.fromList
-          [ (Name.unsafeFromVar v, R.DerivedId r)
+          [ (Name.unsafeParseVar v, R.DerivedId r)
             | (v, (r, _)) <- builtinEffectDecls
           ]
 
@@ -147,7 +147,7 @@ builtinTypeDependentsOfComponent h0 = Rel.searchRan ord builtinDependencies
 -- if we decide to change their names.
 builtinTypes :: [(Name, R.Reference)]
 builtinTypes =
-  Map.toList . Map.mapKeys Name.unsafeFromText $
+  Map.toList . Map.mapKeys Name.unsafeParseText $
     foldl' go mempty builtinTypesSrc
   where
     go m = \case
@@ -286,7 +286,7 @@ instance Show BuiltinDSL where
   show _ = ""
 
 termNameRefs :: Map Name R.Reference
-termNameRefs = Map.mapKeys Name.unsafeFromText $ foldl' go mempty (stripVersion builtinsSrc)
+termNameRefs = Map.mapKeys Name.unsafeParseText $ foldl' go mempty (stripVersion builtinsSrc)
   where
     go m = \case
       B r _tp -> Map.insert r (R.Builtin r) m

parser-typechecker/src/Unison/Codebase/Execute.hs

@@ -1,7 +1,3 @@
-{-# LANGUAGE GADTs #-}
-{-# LANGUAGE OverloadedStrings #-}
-{-# LANGUAGE PartialTypeSignatures #-}
-
 -- | Execute a computation of type '{IO} () that has been previously added to
 -- the codebase, without setting up an interactive environment.
 --
@@ -20,14 +16,15 @@ import Unison.Codebase.Runtime (Runtime)
 import Unison.Codebase.Runtime qualified as Runtime
 import Unison.Names qualified as Names
 import Unison.Parser.Ann (Ann)
+import Unison.Prelude
 import Unison.PrettyPrintEnv qualified as PPE
 import Unison.Symbol (Symbol)
 import Unison.Util.Pretty qualified as P
 
 execute ::
   Codebase.Codebase IO Symbol Ann ->
   Runtime Symbol ->
-  String ->
+  Text ->
   IO (Either Runtime.Error ())
 execute codebase runtime mainName =
   (`finally` Runtime.terminate runtime) . runExceptT $ do
@@ -37,9 +34,9 @@ execute codebase runtime mainName =
     let mainType = Runtime.mainType runtime
     mt <- liftIO $ Codebase.runTransaction codebase $ getMainTerm loadTypeOfTerm parseNames mainName mainType
     case mt of
-      MainTerm.NotAFunctionName s -> throwError ("Not a function name: " <> P.string s)
-      MainTerm.NotFound s -> throwError ("Not found: " <> P.string s)
-      MainTerm.BadType s _ -> throwError (P.string s <> " is not of type '{IO} ()")
+      MainTerm.NotAFunctionName s -> throwError ("Not a function name: " <> P.text s)
+      MainTerm.NotFound s -> throwError ("Not found: " <> P.text s)
+      MainTerm.BadType s _ -> throwError (P.text s <> " is not of type '{IO} ()")
       MainTerm.Success _ tm _ -> do
         let codeLookup = Codebase.toCodeLookup codebase
             ppe = PPE.empty

parser-typechecker/src/Unison/Codebase/MainTerm.hs

@@ -16,7 +16,7 @@ import Unison.Parser.Ann qualified as Parser.Ann
 import Unison.Prelude
 import Unison.Reference (Reference)
 import Unison.Referent qualified as Referent
-import Unison.Syntax.HashQualified qualified as HQ (fromString)
+import Unison.Syntax.HashQualified qualified as HQ (parseText)
 import Unison.Term (Term)
 import Unison.Term qualified as Term
 import Unison.Type (Type)
@@ -26,20 +26,20 @@ import Unison.Var (Var)
 import Unison.Var qualified as Var
 
 data MainTerm v
-  = NotAFunctionName String
-  | NotFound String
-  | BadType String (Maybe (Type v Ann))
+  = NotAFunctionName Text
+  | NotFound Text
+  | BadType Text (Maybe (Type v Ann))
   | Success (HQ.HashQualified Name) (Term v Ann) (Type v Ann)
 
 getMainTerm ::
   (Monad m, Var v) =>
   (Reference -> m (Maybe (Type v Ann))) ->
   Names.Names ->
-  String ->
+  Text ->
   Type.Type v Ann ->
   m (MainTerm v)
 getMainTerm loadTypeOfTerm parseNames mainName mainType =
-  case HQ.fromString mainName of
+  case HQ.parseText mainName of
     Nothing -> pure (NotAFunctionName mainName)
     Just hq -> do
       let refs = Names.lookupHQTerm Names.IncludeSuffixes hq parseNames

parser-typechecker/src/Unison/Codebase/Path.hs

@@ -45,8 +45,8 @@ module Unison.Codebase.Path
     fromName,
     fromName',
     fromPath',
-    fromText,
-    fromText',
+    unsafeParseText,
+    unsafeParseText',
     toAbsoluteSplit,
     toSplit',
     toList,
@@ -93,7 +93,7 @@ import Unison.Name (Convert (..), Name, Parse)
 import Unison.Name qualified as Name
 import Unison.NameSegment (NameSegment)
 import Unison.Prelude hiding (empty, toList)
-import Unison.Syntax.Name qualified as Name (toText, unsafeFromText)
+import Unison.Syntax.Name qualified as Name (toText, unsafeParseText)
 import Unison.Util.List qualified as List
 
 -- `Foo.Bar.baz` becomes ["Foo", "Bar", "baz"]
@@ -311,11 +311,13 @@ fromName' n
     path = fromName n
 
 unsafeToName :: Path -> Name
-unsafeToName = Name.unsafeFromText . toText
+unsafeToName =
+  fromMaybe (error "empty path") . toName
 
 -- | Convert a Path' to a Name
 unsafeToName' :: Path' -> Name
-unsafeToName' = Name.unsafeFromText . toText'
+unsafeToName' =
+  fromMaybe (error "empty path") . toName'
 
 toName :: Path -> Maybe Name
 toName = \case
@@ -348,15 +350,13 @@ instance Show Path where
 
 -- | Note: This treats the path as relative.
 toText :: Path -> Text
-toText path =
-  case toName path of
-    Nothing -> "."
-    Just name -> Name.toText name
+toText =
+  maybe Text.empty Name.toText . toName
 
-fromText :: Text -> Path
-fromText = \case
+unsafeParseText :: Text -> Path
+unsafeParseText = \case
   "" -> empty
-  text -> fromName (Name.unsafeFromText text)
+  text -> fromName (Name.unsafeParseText text)
 
 -- | Construct a Path' from a text
 --
@@ -368,11 +368,11 @@ fromText = \case
 --
 -- >>> show $ fromText' ""
 -- ""
-fromText' :: Text -> Path'
-fromText' = \case
+unsafeParseText' :: Text -> Path'
+unsafeParseText' = \case
   "" -> RelativePath' (Relative mempty)
   "." -> AbsolutePath' (Absolute mempty)
-  text -> fromName' (Name.unsafeFromText text)
+  text -> fromName' (Name.unsafeParseText text)
 
 toText' :: Path' -> Text
 toText' path =

parser-typechecker/src/Unison/DataDeclaration/Dependencies.hs

@@ -27,6 +27,7 @@ import Unison.Reference qualified as Reference
 import Unison.Referent (Referent)
 import Unison.Referent qualified as Referent
 import Unison.Result qualified as Result
+import Unison.Syntax.Var qualified as Var (namespaced)
 import Unison.Term qualified as Term
 import Unison.Type qualified as Type
 import Unison.Typechecker qualified as Typechecker
@@ -83,7 +84,7 @@ hashFieldAccessors ::
   )
 hashFieldAccessors ppe declName vars declRef dd = do
   let accessors :: [(v, (), Term.Term v ())]
-      accessors = DD.generateRecordAccessors mempty (map (,()) vars) declName declRef
+      accessors = DD.generateRecordAccessors Var.namespaced mempty (map (,()) vars) declName declRef
   let typeLookup :: TypeLookup v ()
       typeLookup =
         TypeLookup