Views? Never heard of 'em. Just contracts.

src/Module/Resolver.hs

@@ -9,7 +9,6 @@ module Module.Resolver
 
 import ContentStore.Alias
 import ContentStore.Arboricx (decodeTreeTerm, treeTermDomain)
-import ContentStore.ViewTree (decodeViewTree, viewTreeKind, viewTreeRootTerm)
 import ContentStore.Object
 import ContentStore.Resolver
 import Module.Manifest
@@ -20,15 +19,14 @@ import qualified Data.Set as Set
 import qualified Data.Text as T
 
 -- | A manifest export resolved into the importing source's local lexical scope.
--- The executable term is loaded, while object/view refs remain available for
--- later checker and diagnostics phases.
+-- The executable term is loaded directly; contract terms are not interpreted by
+-- the resolver.
 data ResolvedExport = ResolvedExport
   { resolvedExportSourceName :: T.Text
   , resolvedExportLocalName  :: String
   , resolvedExportObject     :: ObjectRef
   , resolvedExportAbi        :: T.Text
-  , resolvedExportView       :: Maybe ObjectRef
-  , resolvedExportProvenance :: Maybe ViewProvenance
+  , resolvedExportContract   :: Maybe ObjectRef
   , resolvedExportTerm       :: T
   } deriving (Show, Eq)
 
@@ -86,23 +84,14 @@ resolveModuleExport resolver namespace ex = do
         , resolvedExportLocalName = nsVariable namespace (T.unpack sourceName)
         , resolvedExportObject = ref
         , resolvedExportAbi = moduleExportAbi ex
-        , resolvedExportView = moduleExportView ex
-        , resolvedExportProvenance = moduleExportViewProvenance ex
+        , resolvedExportContract = moduleExportContract ex
         , resolvedExportTerm = term
         }
 
 resolveExportTerm :: ObjectResolver -> T.Text -> ObjectRef -> IO T
 resolveExportTerm resolver sourceName ref
-  | objectRefKind ref == viewTreeKind = do
-      bytes <- requireObject "view tree"
-      case decodeViewTree bytes >>= viewTreeRootTerm of
-        Left err -> errorWithoutStackTrace $
-          "Module export " ++ show (T.unpack sourceName)
-          ++ " references invalid view tree " ++ T.unpack (objectRefHash ref)
-          ++ ": " ++ err
-        Right term -> return term
   | objectRefKind ref == unDomain treeTermDomain = do
-      bytes <- requireObject "tree term"
+      bytes <- requireObject
       case decodeTreeTerm bytes of
         Left err -> errorWithoutStackTrace $
           "Module export " ++ show (T.unpack sourceName)
@@ -112,16 +101,15 @@ resolveExportTerm resolver sourceName ref
   | otherwise = errorWithoutStackTrace $
       "Module export " ++ show (T.unpack sourceName)
       ++ " has unsupported object kind " ++ show (T.unpack (objectRefKind ref))
-      ++ "; expected " ++ show (T.unpack viewTreeKind)
-      ++ " or " ++ show (T.unpack (unDomain treeTermDomain))
+      ++ "; expected " ++ show (T.unpack (unDomain treeTermDomain))
   where
-    requireObject label = do
+    requireObject = do
       mBytes <- resolverObject resolver ref
       case mBytes of
         Just bytes -> return bytes
         Nothing -> errorWithoutStackTrace $
           "Module export " ++ show (T.unpack sourceName)
-          ++ " references missing " ++ label ++ " " ++ T.unpack (objectRefHash ref)
+          ++ " references missing tree term " ++ T.unpack (objectRefHash ref)
           ++ " (kind " ++ T.unpack (objectRefKind ref) ++ ")"
 
 resolvedModulesEnv :: [ResolvedModule] -> Env