bugfix: require relative names in import{Wordy,Symboly}Id

parser-typechecker/src/Unison/Syntax/DeclParser.hs

@@ -87,7 +87,7 @@ modifierP = do
   where
     unique = do
       tok <- openBlockWith "unique"
-      optional (openBlockWith "[" *> importWordyId <* closeBlock) >>= \case
+      optional (openBlockWith "[" *> importRelativeWordyId <* closeBlock) >>= \case
         Nothing -> pure (UnresolvedModifier'UniqueWithoutGuid <$ tok)
         Just guid -> pure (UnresolvedModifier'UniqueWithGuid (Name.toText (L.payload guid)) <$ tok)
     structural = do

parser-typechecker/src/Unison/Syntax/FileParser.hs

@@ -55,7 +55,7 @@ file = do
     optional (reserved "namespace") >>= \case
       Nothing -> pure Nothing
       Just _ -> do
-        namespace <- importWordyId <|> importSymbolyId
+        namespace <- importRelativeWordyId <|> importRelativeSymbolyId
         void (optional semi)
         pure (Just namespace.payload)
   let maybeNamespaceVar = Name.toVar <$> maybeNamespace
@@ -401,9 +401,9 @@ stanza = watchExpression <|> unexpectedAction <|> binding
 
 watched :: (Monad m, Var v) => P v m (UF.WatchKind, Text, Ann)
 watched = P.try do
-  kind <- (fmap . fmap . fmap) (Text.unpack . Name.toText) (optional importWordyId)
+  kind <- (fmap . fmap . fmap) (Text.unpack . Name.toText) (optional importRelativeWordyId)
   guid <- uniqueName 10
-  op <- optional (L.payload <$> P.lookAhead importSymbolyId)
+  op <- optional (L.payload <$> P.lookAhead importRelativeSymbolyId)
   guard (op == Just (Name.fromSegment NameSegment.watchSegment))
   tok <- anyToken
   guard $ maybe True (`L.touches` tok) kind

parser-typechecker/src/Unison/Syntax/TermParser.hs

@@ -1355,7 +1355,7 @@ importp = do
     optional $
       fmap Right importWordyId
         <|> fmap Left importSymbolyId
-  suffixes <- optional (some (importWordyId <|> importSymbolyId))
+  suffixes <- optional (some (importRelativeWordyId <|> importRelativeSymbolyId))
   case (prefix, suffixes) of
     (Nothing, _) -> P.customFailure $ UseEmpty kw
     (Just prefix@(Left _), _) -> P.customFailure $ UseInvalidPrefixSuffix prefix suffixes

unison-src/transcripts/idempotent/fix-4536.md

@@ -0,0 +1,128 @@
+``` ucm
+scratch/main> builtins.merge lib.builtin
+
+  Done.
+```
+
+``` unison :error
+foo : Nat
+foo =
+  use Nat .+
+  1 + 2
+```
+
+``` ucm :added-by-ucm
+  Loading changes detected in scratch.u.
+
+  I got confused here:
+
+      3 |   use Nat .+
+
+
+  I was surprised to find a '.' here.
+  I was expecting one of these instead:
+
+  * bang
+  * binding
+  * do
+  * false
+  * force
+  * handle
+  * if
+  * lambda
+  * let
+  * newline or semicolon
+  * pattern
+  * quote
+  * termLink
+  * true
+  * tuple
+  * typeLink
+```
+
+``` unison :error
+namespace .foo
+```
+
+``` ucm :added-by-ucm
+  Loading changes detected in scratch.u.
+
+  I got confused here:
+
+      1 | namespace .foo
+
+
+  I was surprised to find a .foo here.
+```
+
+``` unison :error
+unique[.foo] type Foo = Foo
+```
+
+``` ucm :added-by-ucm
+  Loading changes detected in scratch.u.
+
+  I got confused here:
+
+      1 | unique[.foo] type Foo = Foo
+
+
+  I was surprised to find a .foo here.
+```
+
+``` unison :error
+.foo> 17
+```
+
+``` ucm :added-by-ucm
+  Loading changes detected in scratch.u.
+
+  This looks like the start of an expression here 
+
+      1 | .foo> 17
+
+  but at the file top-level, I expect one of the following:
+
+    - A binding, like .foo = 42 OR
+                      .foo : Nat
+                      .foo = 42
+    - A watch expression, like > .foo + 1
+    - An `ability` declaration, like unique ability Foo where ...
+    - A `type` declaration, like structural type Optional a = None | Some a
+```
+
+``` unison :error
+foo.> 17
+```
+
+``` ucm :added-by-ucm
+  Loading changes detected in scratch.u.
+
+  I got confused here:
+
+      1 | foo.> 17
+
+
+  I was surprised to find a foo.> here.
+  I was expecting one of these instead:
+
+  * ability
+  * bang
+  * binding
+  * do
+  * false
+  * force
+  * handle
+  * if
+  * lambda
+  * let
+  * namespace
+  * newline or semicolon
+  * quote
+  * termLink
+  * true
+  * tuple
+  * type
+  * typeLink
+  * use
+```

unison-src/transcripts/idempotent/generic-parse-errors.md

@@ -33,27 +33,7 @@ namespace.blah = 1
       1 | namespace.blah = 1
 
 
-  I was surprised to find a = here.
-  I was expecting one of these instead:
-
-  * ability
-  * bang
-  * binding
-  * do
-  * false
-  * force
-  * handle
-  * if
-  * lambda
-  * let
-  * newline or semicolon
-  * quote
-  * termLink
-  * true
-  * tuple
-  * type
-  * typeLink
-  * use
+  I was surprised to find a .blah here.
 ```
 
 ``` unison :error

unison-syntax/src/Unison/Syntax/Parser.hs

@@ -24,6 +24,8 @@ module Unison.Syntax.Parser
     failureIf,
     hqInfixId,
     hqPrefixId,
+    importRelativeSymbolyId,
+    importRelativeWordyId,
     importSymbolyId,
     importWordyId,
     label,
@@ -363,12 +365,24 @@ importWordyId = queryToken \case
   L.WordyId (HQ'.NameOnly n) -> Just n
   _ -> Nothing
 
+-- | Parse a wordyId as a relative Name, rejecting any hash
+importRelativeWordyId :: (Ord v) => P v m (L.Token Name)
+importRelativeWordyId = queryToken \case
+  L.WordyId (HQ'.NameOnly n) | Name.isRelative n -> Just n
+  _ -> Nothing
+
 -- | The `+` in: use Foo.bar + as a Name
 importSymbolyId :: (Ord v) => P v m (L.Token Name)
 importSymbolyId = queryToken \case
   L.SymbolyId (HQ'.NameOnly n) -> Just n
   _ -> Nothing
 
+-- | The `+` in: use Foo.bar + as a relative Name
+importRelativeSymbolyId :: (Ord v) => P v m (L.Token Name)
+importRelativeSymbolyId = queryToken \case
+  L.SymbolyId (HQ'.NameOnly n) | Name.isRelative n -> Just n
+  _ -> Nothing
+
 -- | Parse a symboly ID like >>= or &&, discarding any hash
 symbolyDefinitionName :: (Var v) => P v m (L.Token v)
 symbolyDefinitionName = queryToken $ \case