fleshed out HandleInput.DiffNamespaceI

parser-typechecker/src/Unison/Builtin.hs

@@ -11,6 +11,7 @@ module Unison.Builtin
   ,names0
   ,builtinDataDecls
   ,builtinEffectDecls
+  ,builtinConstructorType
   ,builtinTypeDependents
   ,builtinTermsByType
   ,builtinTermsByTypeMention
@@ -75,7 +76,8 @@ typeLookup =
     (Map.fromList $ map snd builtinEffectDecls)
 
 constructorType :: R.Reference -> Maybe CT.ConstructorType
-constructorType = TL.constructorType (typeLookup @Symbol)
+constructorType r = TL.constructorType (typeLookup @Symbol) r
+                <|> Map.lookup r builtinConstructorType
 
 -- | parse some builtin data types, and resolve their free variables using
 -- | builtinTypes' and those types defined herein
@@ -122,7 +124,7 @@ builtinTypes :: [(Name, R.Reference)]
 builtinTypes = Map.toList . Map.mapKeys Name.unsafeFromText
                           $ foldl' go mempty builtinTypesSrc where
   go m = \case
-    B' r -> Map.insert r (R.Builtin r) m
+    B' r _ -> Map.insert r (R.Builtin r) m
     D' r -> Map.insert r (R.Builtin r) m
     Rename' r name -> case Map.lookup name m of
       Just _ -> error . Text.unpack $
@@ -144,21 +146,23 @@ builtinTypes = Map.toList . Map.mapKeys Name.unsafeFromText
 -- WARNING: Don't delete any of these lines, only add corrections.
 builtinTypesSrc :: [BuiltinTypeDSL]
 builtinTypesSrc =
-  [ B' "Int"
-  , B' "Nat"
-  , B' "Float"
-  , B' "Boolean"
-  , B' "Sequence", Rename' "Sequence" "List"
-  , B' "Text"
-  , B' "Char"
-  , B' "Effect", Rename' "Effect" "Request"
-  , B' "Bytes"
-  , B' "Link.Term"
-  , B' "Link.Type"
+  [ B' "Int" CT.Data
+  , B' "Nat" CT.Data
+  , B' "Float" CT.Data
+  , B' "Boolean" CT.Data
+  , B' "Sequence" CT.Data, Rename' "Sequence" "List"
+  , B' "Text" CT.Data
+  , B' "Char" CT.Data
+  , B' "Effect" CT.Data, Rename' "Effect" "Request"
+  , B' "Bytes" CT.Data
+  , B' "Link.Term" CT.Data
+  , B' "Link.Type" CT.Data
   ]
 
+builtinConstructorType :: Map R.Reference CT.ConstructorType
+builtinConstructorType = Map.fromList [ (R.Builtin r, ct) | B' r ct <- builtinTypesSrc ]
 
-data BuiltinTypeDSL = B' Text | D' Text | Rename' Text Text | Alias' Text Text
+data BuiltinTypeDSL = B' Text CT.ConstructorType | D' Text | Rename' Text Text | Alias' Text Text
 
 
 data BuiltinDSL v

parser-typechecker/src/Unison/Codebase/Editor/Command.hs

@@ -154,6 +154,7 @@ data Command m i v a where
 
   LoadTerm :: Reference.Id -> Command m i v (Maybe (Term v Ann))
 
+  -- todo: change this to take Reference and return DeclOrBuiltin
   LoadType :: Reference.Id -> Command m i v (Maybe (Decl v Ann))
 
   LoadTypeOfTerm :: Reference -> Command m i v (Maybe (Type v Ann))

parser-typechecker/src/Unison/Codebase/Editor/HandleInput.hs

@@ -51,6 +51,7 @@ import qualified Data.Set                      as Set
 import           Data.Sequence                  ( Seq(..) )
 import qualified Unison.ABT                    as ABT
 import qualified Unison.Codebase.BranchDiff    as BranchDiff
+import qualified Unison.Codebase.Editor.Output.BranchDiff as OBranchDiff
 import           Unison.Codebase.Branch         ( Branch(..)
                                                 , Branch0(..)
                                                 )
@@ -493,8 +494,19 @@ loop = do
               Path.toAbsolutePath currentPath' <$> [before0, after0]
         before <- Branch.head <$> getAt beforep
         after <- Branch.head <$> getAt afterp
-        diff :: BranchDiff.BranchDiff <- eval . Eval $ BranchDiff.diff0 before after
-        undefined diff
+        diff <- eval . Eval $ BranchDiff.diff0 before after
+        names0 <- basicPrettyPrintNames0
+        ppe <- PPE.suffixifiedPPE <$> prettyPrintEnvDecl (Names names0 mempty)
+        outputDiff <- OBranchDiff.toOutput
+                        loadTypeOfTerm
+                        declOrBuiltin
+                        hqLength
+                        (Branch.toNames0 before)
+                        (Branch.toNames0 after)
+                        ppe
+                        diff
+        -- todo: populate the numberedArgs 😭😭😭
+        respond $ ShowDiffNamespace input ppe outputDiff
 
       -- move the root to a sub-branch
       MoveBranchI Nothing dest -> do
@@ -2333,3 +2345,10 @@ loadTypeOfTerm (Referent.Con (Reference.DerivedId r) cid _) = do
     Nothing -> pure Nothing
 loadTypeOfTerm Referent.Con{} = error $
   reportBug "924628772" "Attempt to load a type declaration which is a builtin!"
+
+declOrBuiltin :: Reference -> Action m i v (Maybe (DD.DeclOrBuiltin v Ann))
+declOrBuiltin r = case r of
+  Reference.Builtin{} ->
+    pure . fmap DD.Builtin $ Map.lookup r Builtin.builtinConstructorType
+  Reference.DerivedId id ->
+    fmap DD.Decl <$> eval (LoadType id)

parser-typechecker/src/Unison/Codebase/Editor/Output.hs

@@ -52,6 +52,7 @@ import Unison.ShortHash (ShortHash)
 import Unison.Var (Var)
 import Unison.Codebase.ShortBranchHash (ShortBranchHash)
 import Unison.Codebase.Editor.RemoteRepo as RemoteRepo
+import Unison.Codebase.Editor.Output.BranchDiff (BranchDiffOutput)
 
 type Term v a = Term.AnnotatedTerm v a
 type ListDetailed = Bool
@@ -161,6 +162,7 @@ data Output v
   | PatchInvolvesExternalDependents PPE.PrettyPrintEnv (Set Reference)
   | WarnIncomingRootBranch (Set ShortBranchHash)
   | ShowDiff Input Names.Diff
+  | ShowDiffNamespace Input PPE.PrettyPrintEnv (BranchDiffOutput v Ann)
   | History (Maybe Int) [(ShortBranchHash, Names.Diff)] HistoryTail
   | ShowReflog [ReflogEntry]
   | NothingTodo Input

parser-typechecker/src/Unison/Codebase/Editor/Output/BranchDiff.hs

@@ -33,7 +33,7 @@ import Unison.Runtime.IOSource (isPropagatedValue)
 data MetadataDiff tm =
   MetadataDiff { addedMetadata :: [tm]
                , removedMetadata :: [tm] }
-               deriving (Ord,Eq,Functor,Foldable,Traversable)
+               deriving (Ord,Eq,Functor,Foldable,Traversable,Show)
 
 instance Semigroup (MetadataDiff tm) where
   a <> b = MetadataDiff (addedMetadata a <> addedMetadata b)
@@ -58,29 +58,29 @@ data BranchDiffOutput v a = BranchDiffOutput {
   movedTerms        :: [RenameTermDisplay v a],
   copiedTypes       :: [RenameTypeDisplay v a],
   copiedTerms       :: [RenameTermDisplay v a]
- }
+ } deriving Show
 
 -- Need to be able to turn a (Name,Reference) into a HashQualified relative to... what.
 -- the new namespace?
 
-type TermDisplay v a = (HashQualified, Type v a, MetadataDiff (MetadataDisplay v a))
-type TypeDisplay v a = (HashQualified, DeclOrBuiltin v a, MetadataDiff (MetadataDisplay v a))
+type TermDisplay v a = (HashQualified, Maybe (Type v a), MetadataDiff (MetadataDisplay v a))
+type TypeDisplay v a = (HashQualified, Maybe (DeclOrBuiltin v a), MetadataDiff (MetadataDisplay v a))
 
-type SimpleTermDisplay v a = (HashQualified, Type v a)
-type SimpleTypeDisplay v a = (HashQualified, DeclOrBuiltin v a)
+type SimpleTermDisplay v a = (HashQualified, Maybe (Type v a))
+type SimpleTypeDisplay v a = (HashQualified, Maybe (DeclOrBuiltin v a))
 
 type UpdateTermDisplay v a = (Maybe [SimpleTermDisplay v a], [TermDisplay v a])
 type UpdateTypeDisplay v a = (Maybe [SimpleTypeDisplay v a], [TypeDisplay v a])
 
 type MetadataDisplay v a = SimpleTermDisplay v a
-type RenameTermDisplay v a = (Referent, Type v a, Set HashQualified, Set HashQualified)
-type RenameTypeDisplay v a = (Reference, DeclOrBuiltin v a, Set HashQualified, Set HashQualified)
+type RenameTermDisplay v a = (Referent, Maybe (Type v a), Set HashQualified, Set HashQualified)
+type RenameTypeDisplay v a = (Reference, Maybe (DeclOrBuiltin v a), Set HashQualified, Set HashQualified)
 type PatchDisplay = (Name, P.PatchDiff)
 
 toOutput :: forall m v a
           . Monad m
-         => (Referent -> m (Type v a))
-         -> (Reference -> m (DeclOrBuiltin v a))
+         => (Referent -> m (Maybe (Type v a)))
+         -> (Reference -> m (Maybe (DeclOrBuiltin v a)))
          -> Int
          -> Names0
          -> Names0
@@ -156,7 +156,7 @@ toOutput typeOf declOrBuiltin hqLen names1 names2 ppe
       (,) <$> (Just <$> for (toList rs_old) (loadOld n))
           <*> for (toList rs_new) (loadNew n rs_old)
     in for (sortOn fst . uniqueBy fst $ nsUpdates <> metadataUpdates) loadEntry
-    
+
   let propagatedUpdates :: Int =
         (Set.size . R3.d2s . BranchDiff.propagatedNamespaceUpdates) typesDiff +
         (Set.size . R3.d2s . BranchDiff.propagatedNamespaceUpdates) termsDiff
@@ -209,7 +209,7 @@ toOutput typeOf declOrBuiltin hqLen names1 names2 ppe
         | (name, BranchDiff.Delete diff) <- Map.toList patchesDiff ]
 
   let movedOrCopiedTerm :: Map Referent (Set Name, Set Name) -> m [RenameTermDisplay v a]
-      movedOrCopiedTerm copiesOrMoves = 
+      movedOrCopiedTerm copiesOrMoves =
         for (Map.toList copiesOrMoves) $ \(r, (ol'names, new'names)) ->
           (,,,) <$> pure r
                 <*> typeOf r
@@ -217,7 +217,7 @@ toOutput typeOf declOrBuiltin hqLen names1 names2 ppe
                 <*> pure (Set.map (\n -> Names2.hqTermName hqLen names2 n r) new'names)
 
   let movedOrCopiedType :: Map Reference (Set Name, Set Name) -> m [RenameTypeDisplay v a]
-      movedOrCopiedType copiesOrMoves = 
+      movedOrCopiedType copiesOrMoves =
         for (Map.toList copiesOrMoves) $ \(r, (ol'names, new'names)) ->
           (,,,) <$> pure r
                 <*> declOrBuiltin r

parser-typechecker/src/Unison/CommandLine/OutputMessages.hs

@@ -20,15 +20,12 @@ import           Unison.Codebase.Editor.Output
 import qualified Unison.Codebase.Editor.Output           as E
 import qualified Unison.Codebase.Editor.Output           as Output
 import qualified Unison.Codebase.Editor.TodoOutput       as TO
-import           Unison.Codebase.Editor.SlurpResult      (SlurpResult(..))
 import qualified Unison.Codebase.Editor.SearchResult'    as SR'
 
 
-import Control.Lens (over, _1)
 import           Data.Bifunctor                (bimap, first)
 import           Data.List                     (sortOn, stripPrefix)
 import           Data.List.Extra               (nubOrdOn, nubOrd)
-import qualified Data.ListLike                 as LL
 import           Data.ListLike                 (ListLike)
 import qualified Data.Map                      as Map
 import qualified Data.Set                      as Set
@@ -36,7 +33,6 @@ import qualified Data.Text                     as Text
 import           Data.Text.IO                  (readFile, writeFile)
 import           Data.Tuple.Extra              (dupe)
 import           Prelude                       hiding (readFile, writeFile)
-import qualified System.Console.ANSI           as Console
 import           System.Directory              (canonicalizePath, doesFileExist)
 import qualified Unison.ABT                    as ABT
 import qualified Unison.UnisonFile             as UF
@@ -45,7 +41,6 @@ import           Unison.Codebase.GitError
 import qualified Unison.Codebase.Path          as Path
 import qualified Unison.Codebase.Patch         as Patch
 import           Unison.Codebase.Patch         (Patch(..))
-import qualified Unison.Codebase.Reflog        as Reflog
 import qualified Unison.Codebase.ShortBranchHash as SBH
 import qualified Unison.Codebase.TermEdit      as TermEdit
 import qualified Unison.Codebase.TypeEdit      as TypeEdit
@@ -72,7 +67,7 @@ import           Unison.NamePrinter            (prettyHashQualified,
                                                 prettyName, prettyShortHash,
                                                 styleHashQualified,
                                                 styleHashQualified', prettyHashQualified')
-import           Unison.Names2                 (Names'(..), Names, Names0)
+import           Unison.Names2                 (Names'(..), Names0)
 import qualified Unison.Names2                 as Names
 import qualified Unison.Names3                 as Names
 import           Unison.Parser                 (Ann, startingLine)
@@ -91,8 +86,6 @@ import qualified Unison.Term                   as Term
 import           Unison.Term                   (AnnotatedTerm)
 import           Unison.Type                   (Type)
 import qualified Unison.TermPrinter            as TermPrinter
-import qualified Unison.Typechecker.TypeLookup as TL
-import qualified Unison.Typechecker            as Typechecker
 import qualified Unison.TypePrinter            as TypePrinter
 import qualified Unison.Util.ColorText         as CT
 import           Unison.Util.Monoid             ( intercalateMap
@@ -107,7 +100,6 @@ import           System.Directory               ( getHomeDirectory )
 import Unison.Codebase.Editor.DisplayThing (DisplayThing(MissingThing, BuiltinThing, RegularThing))
 import qualified Unison.Codebase.Editor.Input as Input
 import qualified Unison.Hash as Hash
-import qualified Unison.Codebase.Branch as Branch
 import qualified Unison.Codebase.Causal as Causal
 import qualified Unison.Codebase.Editor.RemoteRepo as RemoteRepo
 import qualified Unison.Util.List              as List

unison-core/src/Unison/DataDeclaration.hs

@@ -53,8 +53,9 @@ type ConstructorId = Term.ConstructorId
 type DataDeclaration v = DataDeclaration' v ()
 type Decl v a = Either (EffectDeclaration' v a) (DataDeclaration' v a)
 
-data DeclOrBuiltin v a = 
+data DeclOrBuiltin v a =
   Builtin CT.ConstructorType | Decl (Decl v a)
+  deriving (Eq, Show)
 
 asDataDecl :: Decl v a -> DataDeclaration' v a
 asDataDecl = either toDataDecl id