[svn] r6109: nemerle/trunk: ncc/completion/CodeCompletionEngine.n
ncc/completion/CompletionEngineTree.n nc...
trupill
svnadmin at nemerle.org
Sun Feb 5 15:54:57 CET 2006
Log:
Changing Code Completion engine to allow both member and class
completion (needed for MonoDevelop integration). Make nemerlish use the
new Code
Completion Engine.
OverloadPossibility and TypesManager get some of their members internal
to allow class knowledge for MonoDevelop.
Author: trupill
Date: Sun Feb 5 15:54:50 2006
New Revision: 6109
Modified:
nemerle/trunk/ncc/completion/CodeCompletionEngine.n
nemerle/trunk/ncc/completion/CompletionEngineTree.n
nemerle/trunk/ncc/hierarchy/TypesManager.n
nemerle/trunk/ncc/typing/OverloadPossibility.n
nemerle/trunk/tools/nemerlish/eval.n
nemerle/trunk/tools/nemerlish/main.n
Modified: nemerle/trunk/ncc/completion/CodeCompletionEngine.n
==============================================================================
--- nemerle/trunk/ncc/completion/CodeCompletionEngine.n (original)
+++ nemerle/trunk/ncc/completion/CodeCompletionEngine.n Sun Feb 5 15:54:50 2006
@@ -240,6 +240,26 @@
listMessages = [];
}
+ public static LesserInit() : void
+ {
+ LibraryReferenceManager.Init ();
+ NamespaceTree.Init ();
+ Util.Init ();
+ AttributeCompiler.Init ();
+ PreParser.Init ();
+ Passes.Solver = Solver ();
+
+ /*LibraryReferenceManager.AddLibrary("mscorlib");
+ LibraryReferenceManager.AddLibrary ("System");
+ LibraryReferenceManager.AddLibrary ("Nemerle");
+ SystemType.Init ();
+ InternalType.InitSystemTypes ();
+ InternalType.InitNemerleTypes ();
+ LibraryReferenceManager.LoadMacrosFrom ("Nemerle.Macros");*/
+
+ GlobalEnv.Init();
+ }
+
// If you want to recover the messages done by the parser/typer
public Output : System.IO.TextWriter
{
@@ -258,9 +278,7 @@
}
}
- static mutable completionList : list[CompletionInfo];
-
- public RunCompletionEngine () : array[CompletionInfo]
+ public RunCompletionEngine () : CompletionInfo
{
lock (syncObject)
{
@@ -278,7 +296,6 @@
| Assembly as a => LibraryReferenceManager.AddAssembly (a.assembly);
}
- completionList = [];
mutable trees = [];
mutable fileToComplete = "";
@@ -436,18 +453,19 @@
observed_method.GetHeader ().body =
FunBody.Parsed (MainParser.ParseExpr (env, lexer));
+ mutable completionList = null;
try
{
observed_method.RunBodyTyper ();
}
catch
{
- | e is CompletionResult => completionList = e.Overloads.Map (translate_ovpossibility_to_info);
+ | e is CompletionResult => completionList = translate_ovpossibility_to_info (e.Overloads);
| _ => ();
}
IsInCompletionMode = false;
- completionList.ToArray();
+ completionList
}
}
@@ -479,17 +497,44 @@
# region Code completion
- public static translate_ovpossibility_to_info (ovpos : OverloadPossibility) : CompletionInfo
+ public static translate_ovpossibility_to_info (ovpos : list[OverloadPossibility]) : CompletionInfo
{
- match (ovpos.Member)
+ mutable info : CompletionInfo = null;
+ if (ovpos.Length == 0)
+ info = null;
+ else
{
- | y is IField => CompletionMember (complete_field (y))
- | y is IMethod => CompletionMember (complete_method (y))
- | y is IProperty => CompletionMember (complete_property (y))
- | y is IEvent => CompletionMember (complete_event (y))
- | y is TypeInfo => CompletionType (complete_type (y))
- | _ => null
+ mutable complete_types = false;
+ def first = ovpos.Head;
+ when (first is IMethod)
+ {
+ when ((first :> IMethod).GetFunKind() is FunKind.Constructor)
+ {
+ complete_types = true;
+ }
+ }
+ if (complete_types)
+ {
+ }
+ else
+ {
+ def cinfo = CompletionMembers();
+ cinfo.Type = complete_type (first.from.tycon);
+ foreach (possibility in ovpos)
+ {
+ match (possibility.Member) {
+ | y is IField => cinfo.AddMember (complete_field (y));
+ | y is IMethod => cinfo.AddMember (complete_method (y));
+ | y is IProperty => cinfo.AddMember (complete_property (y));
+ | y is IEvent => cinfo.AddMember (complete_event (y));
+ // | y is TypeInfo => cinfo.AddMember (complete_type (y));
+ | _ => ();
+ }
+ }
+ info = cinfo;
+ }
}
+ info
}
static complete_common_member_props (member : IMember, info : NemerleMemberInfo) : void
Modified: nemerle/trunk/ncc/completion/CompletionEngineTree.n
==============================================================================
--- nemerle/trunk/ncc/completion/CompletionEngineTree.n (original)
+++ nemerle/trunk/ncc/completion/CompletionEngineTree.n Sun Feb 5 15:54:50 2006
@@ -47,33 +47,55 @@
public enum CompletionKind
{
- | Member
- | Type
+ | Members
+ | Types
}
- public class CompletionMember : CompletionInfo
+ public class CompletionMembers : CompletionInfo
{
public override CompletionKind : CompletionKind
- { get { CompletionKind.Member } }
+ { get { CompletionKind.Members } }
- public MemberInfo : NemerleMemberInfo;
+ mutable members : list[NemerleMemberInfo];
- public this (member : NemerleMemberInfo)
+ public mutable Type : NemerleTypeInfo;
+ public Members : array[NemerleMemberInfo]
+ {
+ get { members.ToArray() }
+ }
+
+ public AddMember (member : NemerleMemberInfo) : void
+ {
+ members ::= member;
+ }
+
+ public this ()
{
- MemberInfo = member;
+ members = [];
}
}
- public class CompletionType : CompletionInfo
+ public class CompletionTypes : CompletionInfo
{
public override CompletionKind : CompletionKind
- { get { CompletionKind.Type } }
+ { get { CompletionKind.Types } }
- public TypeInfo : NemerleTypeInfo;
+ mutable types : list[NemerleTypeInfo];
+
+ public mutable Namespace : string;
+ public Types : array[NemerleTypeInfo]
+ {
+ get { types.ToArray() }
+ }
+
+ public AddType (t : NemerleTypeInfo) : void
+ {
+ types ::= t;
+ }
- public this (t : NemerleTypeInfo)
+ public this ()
{
- TypeInfo = t;
+ types = [];
}
}
Modified: nemerle/trunk/ncc/hierarchy/TypesManager.n
==============================================================================
--- nemerle/trunk/ncc/hierarchy/TypesManager.n (original)
+++ nemerle/trunk/ncc/hierarchy/TypesManager.n Sun Feb 5 15:54:50 2006
@@ -33,7 +33,7 @@
/* ---------------------------------------------------------------------- */
public partial class TypesManager
{
- protected internal mutable infos : list [TypeBuilder] = [];
+ public mutable infos : list [TypeBuilder] = [];
internal mutable run_phase : int;
protected attribute_macros_queue : Nemerle.Collections.Heap [AttributeMacroExpansion] = Nemerle.Collections.Heap (100);
Modified: nemerle/trunk/ncc/typing/OverloadPossibility.n
==============================================================================
--- nemerle/trunk/ncc/typing/OverloadPossibility.n (original)
+++ nemerle/trunk/ncc/typing/OverloadPossibility.n Sun Feb 5 15:54:50 2006
@@ -217,7 +217,7 @@
member : IMember;
solver : Solver;
is_static : bool;
- from : MType.Class;
+ internal from : MType.Class;
method_typarms : list [TyVar];
local_context : LocalContext;
mutable generic_specifier : list [TyVar];
Modified: nemerle/trunk/tools/nemerlish/eval.n
==============================================================================
--- nemerle/trunk/tools/nemerlish/eval.n (original)
+++ nemerle/trunk/tools/nemerlish/eval.n Sun Feb 5 15:54:50 2006
@@ -179,12 +179,21 @@
// provides a list of possible completion types and members
mutable static IsCompletionMode : bool = false;
- public Complete (code: string) : list [Nemerle.Completion.CompletionInfo] {
+ public Complete (code: string) : Nemerle.Completion.CompletionInfo {
IsCompletionMode = true;
+ Evaluator.code = code;
Message.InitOutput (System.IO.StreamWriter (System.IO.MemoryStream ()));
- mutable completionList = [];
+ mutable completionList : Nemerle.Completion.CompletionInfo = null;
- Evaluator.code = code;
+ Nemerle.Completion.Engine.LesserInit();
+ def lexer = LexerString (code, Location (0, 1, 1));
+
+ Passes.Hierarchy = TypesManager();
+ Passes.ParsingPipeline = MainParser.Parse;
+ Passes.ScanningPipeline = ScanTypeHierarchy.ProcessDeclaration;
+
+ def decls = Passes.ParsingPipeline (lexer);
+ List.Iter (decls, Passes.ScanningPipeline);
// Link ourselves.
Options.ReferencedLibraries = System.Reflection.Assembly.GetAssembly
@@ -195,30 +204,37 @@
def prevlocals = Evaluator.locals;
def prevvals = Evaluator.vals;
- try {
- Passes.Run ();
+ System.Console.WriteLine ("8");
+ System.Console.WriteLine (code);
+ Passes.Hierarchy.Run ();
+ try {
mutable my_method = null;
- Passes.Hierarchy.Iter (fun (ti) {
+ System.Console.WriteLine ("9, infos == null: {0}", Passes.Hierarchy.infos == null);
+ Passes.Hierarchy.infos.Iter (fun (ti) {
def members = ti.GetMethods();
+ System.Console.WriteLine ("9bis");
members.Iter ( fun (member : IMethod) {
- when (member.Name == "Run") {
+ when (member.Name == "Main") {
my_method = member :> MethodBuilder;
}
} );
} );
- def lexer = LexerCompletion (Evaluator.code, Evaluator.code.Length);
+ System.Console.WriteLine ("10");
+ def lexer = LexerCompletion (Evaluator.code + " ", Evaluator.code.Length);
+ System.Console.WriteLine ("11, my_method == null: {0}", my_method == null);
my_method.GetHeader ().body =
FunBody.Parsed (MainParser.ParseExpr (my_method.DeclaringType.GlobalEnv, lexer));
+ System.Console.WriteLine ("12");
+ my_method.RunBodyTyper ();
Evaluator.compiled = false
}
catch {
| e => match (e) {
- | cr is Nemerle.Compiler.CompletionResult => completionList = cr.Overloads.Map
- (Nemerle.Completion.Engine.translate_ovpossibility_to_info);
+ | cr is Nemerle.Compiler.CompletionResult => completionList = Nemerle.Completion.Engine.translate_ovpossibility_to_info (cr.Overloads);
| _ is AssertionException
| _ is Recovery
| _ is System.ApplicationException =>
@@ -236,6 +252,9 @@
}
Message.InitOutput (System.Console.Out);
+ Passes.ParsingPipeline = fun (_) { [null] };
+ Passes.ScanningPipeline = DoTheStuff;
+
IsCompletionMode = false;
completionList
}
Modified: nemerle/trunk/tools/nemerlish/main.n
==============================================================================
--- nemerle/trunk/tools/nemerlish/main.n (original)
+++ nemerle/trunk/tools/nemerlish/main.n Sun Feb 5 15:54:50 2006
@@ -245,18 +245,21 @@
def printcomp (c)
{
- def possibilities = e.Complete (c);
- if (possibilities.Length == 0) {
+ def information = e.Complete (c);
+ when (information is CompletionMembers)
+ {
+ def possibilities = (information :> CompletionMembers);
+ if (possibilities.Members.Length == 0) {
SC.WriteLine ("(no possibilities found)");
}
else {
- def reversePossibilities = possibilities.Reverse ();
+ def reversePossibilities = Nemerle.Collections.List.FromArray (possibilities.Members).Reverse ();
foreach (possibility in reversePossibilities)
{
- match (possibility.CompletionKind)
+ /*match (possibility.CompletionKind)
{
- | Member => def minfo = possibility :> CompletionMember;
- match (minfo.MemberInfo) {
+ | Member => def minfo = possibility :> CompletionMember;*/
+ match (possibility) {
| f is FieldInfo => mutable name = f.Name;
when (f.IsMutable)
name = "mutable " + name;
@@ -306,7 +309,7 @@
| _ => ();
}
- | Type => def tinfo = possibility :> CompletionType;
+ /*| Type => def tinfo = possibility :> CompletionType;
match (tinfo.TypeInfo) {
| decl is DeclaredTypeInfo => mutable name = "";
if (decl.IsNested)
@@ -337,6 +340,7 @@
| _ => ();
}
+ }*/
}
}
}
More information about the svn
mailing list