Add limited completion support.

Author: Tak

src/UnityScript.MonoDevelop/Completion/CompletionFinder.boo

@@ -0,0 +1,29 @@
+namespace UnityScript.MonoDevelop.Completion
+
+import UnityScript
+
+import Boo.Lang.Compiler
+import Boo.Lang.Compiler.Steps
+import Boo.Lang.Compiler.Ast
+import Boo.Lang.Compiler.IO
+import Boo.Lang.Compiler.TypeSystem
+
+class CompletionFinder(DepthFirstVisitor):
+
+       public static final CompletionToken = "__complete_me__"
+
+       _type as IType
+
+       def FindCompletionTypeFor(node as Node):
+               VisitAllowingCancellation(node)
+               return _type
+
+       override def LeaveMemberReferenceExpression(node as MemberReferenceExpression):
+               if node.Name != CompletionToken:
+                       return
+
+               Found(node.Target.ExpressionType)
+
+       protected def Found(type):
+               _type = type
+               Cancel()

src/UnityScript.MonoDevelop/Completion/ResolveMonoBehaviourType.boo

@@ -0,0 +1,23 @@
+namespace UnityScript.MonoDevelop.Completion
+
+import UnityScript
+
+import Boo.Lang.Compiler
+import Boo.Lang.Compiler.Steps
+import Boo.Lang.Compiler.Ast
+import Boo.Lang.Compiler.IO
+import Boo.Lang.Compiler.TypeSystem
+
+class ResolveMonoBehaviourType(AbstractCompilerStep):
+       override def Run():
+               type = FindReferencedType("UnityEngine.MonoBehaviour")
+               (Parameters as UnityScriptCompilerParameters).ScriptBaseType = type or object
+
+       def FindReferencedType(typeName as string):
+               for reference in Parameters.References:
+                       assemblyRef = reference as Boo.Lang.Compiler.TypeSystem.Reflection.IAssemblyReference
+                       if assemblyRef is null:
+                               continue
+                       type = assemblyRef.Assembly.GetType(typeName)
+                       if type is not null:
+                               return type

src/UnityScript.MonoDevelop/Completion/UnityScriptEditorCompletion.boo

@@ -1,22 +1,36 @@
 namespace UnityScript.MonoDevelop.Completion
 
+import System.Collections.Generic
+
+import UnityScript
 import UnityScript.MonoDevelop
 import UnityScript.MonoDevelop.ProjectModel
 
+import MonoDevelop.Core
+import MonoDevelop.Projects
 import MonoDevelop.Projects.Dom.Parser 
 import MonoDevelop.Ide.Gui.Content
 import MonoDevelop.Ide.CodeCompletion
 
+import Boo.Lang.Compiler
+import Boo.Lang.Compiler.Steps
+import Boo.Lang.Compiler.Ast
+import Boo.Lang.Compiler.IO
+import Boo.Lang.Compiler.TypeSystem
 import Boo.Lang.PatternMatching
 
 class UnityScriptEditorCompletion(CompletionTextEditorExtension):
 
 	_dom as ProjectDom
+	_resolver as UnityScriptTypeResolver
+	_project as DotNetProject
 
 	override def Initialize():
 		super()
 		_dom = ProjectDomService.GetProjectDom(Document.Project) or ProjectDomService.GetFileDom(Document.FileName)
 		InstallUnityScriptSyntaxModeIfNeeded()
+		_resolver = UnityScriptTypeResolver()
+		_project = Document.Project as DotNetProject
 
 	def InstallUnityScriptSyntaxModeIfNeeded():
 		view = Document.GetContent[of MonoDevelop.SourceEditor.SourceEditorView]()
@@ -29,7 +43,7 @@ class UnityScriptEditorCompletion(CompletionTextEditorExtension):
 		if mode is not null:
 			view.Document.SyntaxMode = mode
 		else:
-			MonoDevelop.Core.LoggingService.LogWarning(GetType() + " could not get SyntaxMode for mimetype '" + mimeType + "'.")
+			LoggingService.LogWarning(GetType() + " could not get SyntaxMode for mimetype '" + mimeType + "'.")
 
 	override def ExtendsEditor(doc as MonoDevelop.Ide.Gui.Document, editor as IEditableTextBuffer):
 		return IsUnityScriptFile(doc.Name)
@@ -46,12 +60,35 @@ class UnityScriptEditorCompletion(CompletionTextEditorExtension):
 				return ImportCompletionDataFor('')
 
 			case '.':
-				lineText = GetLineText(context.TriggerLine)
-				if not lineText.StartsWith("import "):
-					return null
+				# lineText = GetLineText(context.TriggerLine)
+				# if not lineText.StartsWith("import "):
+				# 	return null
+				
+				# nameSpace = lineText[len("import "):context.TriggerLineOffset-2].Trim()
+				# return ImportCompletionDataFor(nameSpace)
+				result = null as CompletionDataList
+				text = string.Format ("{0}{1} {2}", Document.TextEditor.GetText (0, context.TriggerOffset),
+				                                    CompletionFinder.CompletionToken,
+				                                    Document.TextEditor.GetText (context.TriggerOffset, Document.TextEditor.TextLength))
+				print text
+				_resolver.Input.Clear()
+				_resolver.Input.Add(StringInput("completion text", text))
+				
+				ast = _resolver.Run()
+				print ast.ToCodeString()
 
-				nameSpace = lineText[len("import "):context.TriggerLineOffset-2].Trim()
-				return ImportCompletionDataFor(nameSpace)
+				finder = CompletionFinder()
+				type = finder.FindCompletionTypeFor(ast)
+				print type
+				if (null != type):
+					result = CompletionDataList()
+					resultHash = Dictionary[of string,string]()
+					for member in type.GetMembers():
+						print member
+						resultHash[member.Name] = member.Name
+					result.AddRange(resultHash.Keys)
+       
+				return result
 
 			otherwise:
 				return null

src/UnityScript.MonoDevelop/Completion/UnityScriptTypeResolver.boo

@@ -0,0 +1,42 @@
+namespace UnityScript.MonoDevelop.Completion
+
+import UnityScript
+
+import Boo.Lang.Compiler
+import Boo.Lang.Compiler.Steps
+import Boo.Lang.Compiler.Ast
+import Boo.Lang.Compiler.IO
+import Boo.Lang.Compiler.TypeSystem
+
+class UnityScriptTypeResolver:
+
+       _compiler = UnityScriptCompiler()
+
+       def constructor():
+               pipeline = UnityScriptCompiler.Pipelines.AdjustBooPipeline(Boo.Lang.Compiler.Pipelines.Compile())
+               pipeline.InsertAfter(UnityScript.Steps.Parse, ResolveMonoBehaviourType())
+               pipeline.BreakOnErrors = false
+
+               _compiler.Parameters.ScriptMainMethod = "Awake"
+               _compiler.Parameters.Pipeline = pipeline
+               imports = _compiler.Parameters.Imports
+               imports.Add("UnityEngine")
+               imports.Add("System.Collections")
+
+       Input:
+               get: return Parameters.Input
+
+       References:
+               get: return Parameters.References
+
+       Parameters:
+               private get: return _compiler.Parameters
+
+       def AddReference(reference as string):
+               References.Add(Parameters.LoadAssembly(reference, true))
+
+       def Run():
+               result = _compiler.Run()
+               for error in result.Errors:
+                       print error
+               return result.CompileUnit

src/UnityScript.MonoDevelop/UnityScript.MonoDevelop.booproj

@@ -58,10 +58,15 @@
     <Compile Include="ProjectModel\UnityScriptParser.boo" />
     <Compile Include="ProjectModel\UnityScriptProjectParameters.boo" />
     <Compile Include="CommandHandlers\withAtomicUndoOn.boo" />
+    <Compile Include="Completion\ResolveMonoBehaviourType.boo" />
+    <Compile Include="Completion\CompletionFinder.boo" />
   </ItemGroup>
   <ProjectExtensions>
     <MonoDevelop>
       <Properties InternalTargetFrameworkVersion="3.5" />
     </MonoDevelop>
   </ProjectExtensions>
+  <ItemGroup>
+    <None Include="Completion\UnityScriptTypeResolver.boo" />
+  </ItemGroup>
 </Project>