[svn] r6524: nemerle/trunk/ncc: hierarchy/NamespaceTree.n typing/Typer.n

[VladD2]

Log:
Completion logic update.

Author: VladD2
Date: Tue Aug 15 17:51:05 2006
New Revision: 6524

Modified:
   nemerle/trunk/ncc/hierarchy/NamespaceTree.n
   nemerle/trunk/ncc/typing/Typer.n

Modified: nemerle/trunk/ncc/hierarchy/NamespaceTree.n
==============================================================================
--- nemerle/trunk/ncc/hierarchy/NamespaceTree.n	(original)
+++ nemerle/trunk/ncc/hierarchy/NamespaceTree.n	Tue Aug 15 17:51:05 2006
@@ -71,6 +71,18 @@
         Value = v;
       }
 
+      public EnsureCached() : void
+      {
+        match (Value)
+        {
+          | NotLoaded (extType) => extType.ConstructTypeInfo (this, true)
+          | NotLoadedList (elems) =>
+            Value = TypeInfoCache.CachedAmbiguous (elems.Map (
+              fun (e) { e.ConstructTypeInfo (this, false); e.tycon }))
+          | _ => () 
+        }
+      }
+      
       [Nemerle.OverrideObjectEquals]
       public Equals (other : Node) : bool {
         if (other == null) false

Modified: nemerle/trunk/ncc/typing/Typer.n
==============================================================================
--- nemerle/trunk/ncc/typing/Typer.n	(original)
+++ nemerle/trunk/ncc/typing/Typer.n	Tue Aug 15 17:51:05 2006
@@ -26,6 +26,7 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
+using SCG = System.Collections.Generic;
 using Nemerle.Collections;
 using Nemerle.Utility;
 using Nemerle.Logging;
@@ -43,10 +44,19 @@
 
 namespace Nemerle.Compiler
 {
-  [Record (Include = [Overloads, NamePrefix])]
+  public variant Elem
+  {
+    | Node       { Name : string; node : NamespaceTree.Node; }
+    | Local { Value : LocalValue }
+    | Overloads  { Values : list [OverloadPossibility]; }
+  }
+
+  [Record (Include = [Elems, NamePrefix])]
   public class CompletionResult : System.Exception
   {
-    public Overloads : list [OverloadPossibility];
+    public Elems : SCG.IList [Elem];
+
+    //public Overloads : list [OverloadPossibility];
     public NamePrefix : string;
     [Accessor (flags = WantSetter)]
     mutable object_type : MType;
@@ -1415,43 +1425,40 @@
               | Some (lst)
               | None with lst = [] => lst
             }
-          def compl_exc = CompletionResult (member_overloads + name_overloads, name.Id);
+
+          def elems = SCG.List ();
+          elems.Add(Elem.Overloads (member_overloads + name_overloads));
+
+          def compl_exc = CompletionResult (elems, name.Id);
           compl_exc.ObjectType = tobj.Type.Fix();
           throw compl_exc
 
         | PT.PExpr.ToComplete (name) =>
           def prefix = name.Id;
-          def builder = CurrentMethodBuilder;
-          mutable overloads = TypeNameFull (expression, expected, for_completion = true);
+          //def builder = CurrentMethodBuilder;
+          def overloads = TypeNameFull (expression, expected, for_completion = true);
+
+          def elems = SCG.List ();
+          elems.Add(Elem.Overloads (overloads));
           
           // find locals
           foreach ((name, local) when name.Id.StartsWith (prefix) in local_context.GetLocals ())
-            overloads ::= LocalValueCompletionPossibility (
-              this, local.Type, null, null, builder, null, local);
+            elems.Add(Elem.Local (local));
 
-          // find namespaces
+          // find namespaces and types
 
-          def find_namespaces (ns, processParent)
-          {
-            when (ns != null)
+          def find_namespaces (ns)
             {
-              when (ns.Children != null)
-                foreach ((name, subNs) in ns.Children.KeyValuePairs)
-                  when (subNs.Value is NamespaceTree.TypeInfoCache.NamespaceReference && name.StartsWith (prefix))
-                    overloads ::= NamespaceCompletionPossibility (
-                      this, null, null, null, CurrentMethodBuilder, null, false, name, subNs.GetDisplayName ());
-
-              when (processParent)
-                find_namespaces (ns.Parent, processParent)
+            foreach ((name, node) in ns.Children.KeyValuePairs)
+              when (!(node.Value is NamespaceTree.TypeInfoCache.No) && name.StartsWith (prefix))
+                elems.Add(Elem.Node (name, node));
             }
-          }
-
-          find_namespaces (env.CurrentNamespace.Parent, true);
 
-          foreach (ns in env.OpenNamespaces)
-            find_namespaces (ns, false);
+          find_namespaces (Manager.CoreEnv.CurrentNamespace);
+          foreach (ns when ns.Children != null in name.context.OpenNamespaces)
+            find_namespaces (ns);
             
-          throw CompletionResult (overloads, prefix)
+          throw CompletionResult (elems, prefix)
  
           
         | PT.PExpr.Member (_, _) =>