src/Pure/Thy/sessions.scala

         case Nil => this
         case errs => error(cat_lines(errs))
       }
   }
 
-  def deps(sessions: T,
+  def deps(sessions_structure: T,
       global_theories: Map[String, String],
       progress: Progress = No_Progress,
       inlined_files: Boolean = false,
       verbose: Boolean = false,
       list_files: Boolean = false,

         }
       }
     }
 
     val session_bases =
-      (Map.empty[String, Base] /: sessions.imports_topological_order)({
+      (Map.empty[String, Base] /: sessions_structure.imports_topological_order)({
         case (session_bases, session_name) =>
           if (progress.stopped) throw Exn.Interrupt()
 
-          val info = sessions(session_name)
+          val info = sessions_structure(session_name)
           try {
             val parent_base: Sessions.Base =
               info.parent match {
                 case None => Base.bootstrap(global_theories)
                 case Some(parent) => session_bases(parent)

                   Graph_Display.Node(name.theory_base_name, "theory." + name.theory)
                 else session_node(qualifier)
               }
 
               val imports_subgraph =
-                sessions.imports_graph.restrict(sessions.imports_graph.all_preds(info.deps).toSet)
+                sessions_structure.imports_graph.
+                  restrict(sessions_structure.imports_graph.all_preds(info.deps).toSet)
 
               val graph0 =
                 (Graph_Display.empty_graph /: imports_subgraph.topological_order)(
                   { case (g, session) =>
                       val a = session_node(session)

 
   /* base info */
 
   sealed case class Base_Info(
     session: String,
-    sessions: T,
+    sessions_structure: T,
     errors: List[String],
     base: Base,
     infos: List[Info])
   {
     def check_base: Base = if (errors.isEmpty) base else error(cat_lines(errors))