[svn] r7081: vs-plugin/trunk/Nemerle.Compiler.Utils: Nemerle.Compiler.Utils.csproj Nemerle.Completion2/Eng...

[VladD2]

Log:
Move completion code from the compiler.

Author: VladD2
Date: Tue Dec 12 12:17:48 2006
New Revision: 7081

Added:
   vs-plugin/trunk/Nemerle.Compiler.Utils/Nemerle.Completion2/Engine/Engine.Completion.n
Modified:
   vs-plugin/trunk/Nemerle.Compiler.Utils/Nemerle.Compiler.Utils.csproj

Modified: vs-plugin/trunk/Nemerle.Compiler.Utils/Nemerle.Compiler.Utils.csproj
==============================================================================
--- vs-plugin/trunk/Nemerle.Compiler.Utils/Nemerle.Compiler.Utils.csproj	(original)
+++ vs-plugin/trunk/Nemerle.Compiler.Utils/Nemerle.Compiler.Utils.csproj	Tue Dec 12 12:17:48 2006
@@ -164,6 +164,9 @@
       <CopyToOutputDirectory>Always</CopyToOutputDirectory>
     </Content>
   </ItemGroup>
+  <ItemGroup>
+    <Compile Include="Nemerle.Completion2\Engine\Engine.Completion.n" />
+  </ItemGroup>
   <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.

Added: vs-plugin/trunk/Nemerle.Compiler.Utils/Nemerle.Completion2/Engine/Engine.Completion.n
==============================================================================
--- (empty file)
+++ vs-plugin/trunk/Nemerle.Compiler.Utils/Nemerle.Completion2/Engine/Engine.Completion.n	Tue Dec 12 12:17:48 2006
@@ -0,0 +1,173 @@
+using System;
+using System.IO;
+using System.Diagnostics;
+
+using SCG = System.Collections.Generic;
+using SR  = System.Reflection;
+
+using Nemerle.Assertions;
+using Nemerle.Collections;
+using Nemerle.Compiler;
+using Nemerle.Compiler.Parsetree;
+using Nemerle.Imperative;
+using Nemerle.Utility;
+using Nemerle.Compiler.Utils;
+
+using TT = Nemerle.Compiler.Typedtree;
+using TExpr = Nemerle.Compiler.Typedtree.TExpr;
+
+namespace Nemerle.Completion2
+{
+	public partial class Engine
+	{
+    protected override Complete (
+      expression : PExpr,
+      expected : TyVar,
+      typer : Typer,
+      env : GlobalEnv) : void
+    {
+      match (expression)
+      {
+        | PExpr.Member (obj, Splicable.HalfId (name)) =>
+          def obj = obj; // for debug
+          def name = name; // for debug
+          def elems = SCG.List ();
+          def tobj = typer.TypeExpr (obj);
+
+          def AddOverloads(overloads)
+          {
+            unless (overloads.IsEmpty)
+              elems.Add(Elem.Overloads (overloads));
+          }
+
+          def tryInterpretAsGlobals()
+          {
+            def nss = this.CoreEnv.NameTree.NamespaceTree :: name.GetEnv(env).OpenNamespaces;
+            Completion.AddTypesAndNamespaces (elems, nss, obj, name, false);
+          }
+
+          def tryInterpretAsQualifiedName() : void
+          {
+            // Try interpret as qualified name...
+            AddOverloads(typer.TypeNameFull(expression, Solver.FreshTyVar (), true));
+          }
+
+          def tryInterpretAsExtentionMethods() : void
+          {
+            // Try get extention methods...
+            def extMethods = this.LibrariesManager.GetExtensionMethods (name.Id, name.GetEnv (env), true);
+            def ty = tobj.MType;
+
+            when (ty != null)
+              foreach (method when this.IsExtensionMethod(method, ty) in extMethods)
+                foreach (over in typer.ConstructMethodOverload (method, null, true))
+                {
+                  over.ExtensionMethodObject = tobj;
+                  elems.Add(Elem.Overload (over));
+                }
+          }
+
+          def tryInterpretAsMemberAccessAtGeneralExpression() : void
+          {
+            // Try interpret as member access at general expression...
+            match (typer.TypeMember (tobj, name, expected, for_completion = true))
+            {
+              | Some (lst) => AddOverloads(lst);
+              | None       => ()
+            }
+          }
+
+          tryInterpretAsGlobals();
+          tryInterpretAsQualifiedName();
+          tryInterpretAsExtentionMethods();
+          tryInterpretAsMemberAccessAtGeneralExpression();
+
+          def compl_exc = CompletionResult (elems, name.Id);
+          compl_exc.ObjectType = tobj.Type.Fix();
+          throw compl_exc
+
+        | PExpr.ToComplete (name) =>
+          def prefix = name.Id;
+          //def builder = CurrentMethodBuilder;
+          def overloads = typer.TypeNameFull (expression, expected, for_completion = true);
+
+          def elems = SCG.List ();
+          elems.Add(Elem.Overloads (overloads));
+          
+          // find locals
+          def CmpOptions = System.StringComparison.InvariantCultureIgnoreCase;
+          foreach ((name, local) when name.Id.StartsWith (prefix, CmpOptions) in typer.GetLocals().GetLocals())
+            elems.Add(Elem.Local (local));
+
+          // add namespaces and types
+
+          def nss = this.CoreEnv.NameTree.NamespaceTree :: name.GetEnv(env).OpenNamespaces;
+          Completion.AddTypesAndNamespaces (elems, nss, null, name, false);
+            
+          throw CompletionResult (elems, prefix)
+
+        | _ => throw System.NotImplementedException ();
+      }
+    }
+
+    /// Process completion in patterns.
+    protected override CompletePattern (
+      expression         : PExpr,
+      matched_value_type : TyVar,
+      _patternTyper       : Typer.PatternTyper,
+      _env                : GlobalEnv
+    )
+      : void //
+    {
+      match (expression)
+      {
+        | PExpr.Is (_nested, PExpr.ToComplete (name)) with obj = null
+        | PExpr.Is (_nested, PExpr.Member (obj, Parsetree.Splicable.HalfId (name))) =>
+          def obj = obj;
+          def name = name;
+          def elems = SCG.List ();
+
+          def nss = this.CoreEnv.NameTree.NamespaceTree 
+            :: name.GetEnv(this.CoreEnv).OpenNamespaces;
+          Completion.AddTypesAndNamespaces (elems, nss, obj, name, true);
+
+          throw CompletionResult (elems, name.Id);
+
+        | PExpr.ToComplete (name) with obj = null
+        | PExpr.Member (obj, Parsetree.Splicable.HalfId (name)) =>
+          def elems = SCG.List ();
+          match (matched_value_type.Hint)
+          {
+            | Some(ty) =>
+              def prefix = name.Id;
+              def option = System.StringComparison.InvariantCultureIgnoreCase;
+              match (ty)
+              {
+                | MType.Class (ti, _args) =>
+                  match (ti.GetTydecl ())
+                  {
+                    | TT.TypeDeclaration.Variant (members) =>
+                      foreach (m when m.Name.StartsWith (prefix, option) in members)
+                        elems.Add (Elem.Node (m.Name, m.NamespaceNode));
+
+                      throw CompletionResult (elems, name.Id);
+
+                  //| TypeDeclaration.VariantOption =>
+                    | _ => System.Console.WriteLine(ty);
+                  }
+                | _ => System.Console.WriteLine(ty);
+              }
+
+            | None => System.Console.WriteLine(matched_value_type);
+          }
+
+          def nss = this.CoreEnv.NameTree.NamespaceTree 
+            :: name.GetEnv(this.CoreEnv).OpenNamespaces;
+          Completion.AddTypesAndNamespaces (elems, nss, obj, name, true);
+
+          throw CompletionResult (elems, name.Id);
+        | _ => ()
+      }
+    }
+  } // end class Engine
+} // end namespace