anchor.diff:           raise (Err (Util.format1 "Expecting an interface, got %s" intf));
         if not (Parser.Dep.is_implementation impl) then
            raise (Err (Util.format1 "Expecting an implementation, got %s" impl));
  -      [LDInterfaceOfCurrentFile intf]
  +      [LDInterfaceOfCurrentFile (dummy_tf_of_fname intf)]
       | [impl] ->
         []
       | _ ->
  
positive.code: (** Load the file or files described by `task` **)
  let load_one (env: env_t) (task: load_dependency_task) =
    match task with
    | LDInterleaved (intf, impl) -> tc_one env (Some intf) impl
    | LDSingle intf_or_impl -> tc_one env None intf_or_impl
    | LDInterfaceOfCurrentFile intf -> Universal.load_interface_decls env intf
  
  (** Build a list of load tasks from a list of dependencies **)
  let rec tasks_of_deps (deps: list string) (final_tasks: list<load_dependency_task>) =
    match deps with
    | intf :: impl :: deps' when needs_interleaving intf impl ->
      LDInterleaved (intf, impl) :: tasks_of_deps deps' final_tasks
    | intf_or_impl :: deps' ->
      LDSingle intf_or_impl :: tasks_of_deps deps' final_tasks
    | [] -> final_tasks
  
  // Note: many of these functions are passing env around just for the sake of
  // providing a link to the solver (to avoid a cross-project dependency). They're
  
negative.code:     tasks_of_deps deps load_intf_tasks in
    deps, tasks
  
  (** Environments created while processing dependency loading tasks **)
  type deps_stack_t = list<(load_dependency_task * env_t)>
  
  (** Push into `env`, then run `fn` and revert all changes in `stack` if it fails.
  
  