internal static CompletionData ConvertMirrorToCompletionData(StaticMirror mirror, bool useShorterName = false, ElementResolver resolver = null) { var method = mirror as MethodMirror; if (method != null) { string methodName = method.MethodName; string signature = method.ToString(); CompletionType type = method.IsConstructor ? CompletionType.Constructor : CompletionType.Method; return(new CompletionData(methodName, type) { Stub = signature }); } var property = mirror as PropertyMirror; if (property != null) { string propertyName = property.PropertyName; return(new CompletionData(propertyName, CompletionType.Property)); } var classMirror = mirror as ClassMirror; if (classMirror != null) { string className = useShorterName ? GetShortClassName(classMirror, resolver) : classMirror.Alias; return(new CompletionData(className, CompletionType.Class)); } else { throw new ArgumentException("Invalid argument"); } }
public void LookupResolvedName_ForPartialNestedExpression_RewriteAst() { var astNodes = CoreUtils.BuildASTList(core, "p = Autodesk.Point.ByCoordinates(Autodesk.Point.ByCoordinates(x, y, z).X, y, z).X;"); var elementResolver = new ElementResolver(); elementResolver.AddToResolutionMap("Autodesk.Point", "Autodesk.DS.Geometry.Point", "Protogeometry.dll"); var newNodes = ElementRewriter.RewriteElementNames(core.ClassTable, elementResolver, astNodes); Assert.AreEqual("p = Autodesk.DS.Geometry.Point.ByCoordinates(Autodesk.DS.Geometry.Point.ByCoordinates(x, y, z).X, y, z).X;\n", newNodes.ElementAt(0).ToString()); ///////////////////////////////////// astNodes = CoreUtils.BuildASTList(core, "p = Autodesk.DS.Point.ByCoordinates(Autodesk.Point.ByCoordinates(x, y, z).X, y, z).X;"); elementResolver = new ElementResolver(); elementResolver.AddToResolutionMap("Autodesk.Point", "Autodesk.DS.Geometry.Point", "Protogeometry.dll"); elementResolver.AddToResolutionMap("Autodesk.DS.Point", "Autodesk.DS.Geometry.Point", "Protogeometry.dll"); newNodes = ElementRewriter.RewriteElementNames(core.ClassTable, elementResolver, astNodes); Assert.AreEqual("p = Autodesk.DS.Geometry.Point.ByCoordinates(Autodesk.DS.Geometry.Point.ByCoordinates(x, y, z).X, y, z).X;\n", newNodes.ElementAt(0).ToString()); ////////////////////////////////////// astNodes = CoreUtils.BuildASTList(core, "p = Autodesk.DS.Geometry.Point.ByCoordinates(Autodesk.Point.ByCoordinates(x, y, z).X, y, z).X;"); elementResolver = new ElementResolver(); elementResolver.AddToResolutionMap("Autodesk.Point", "Autodesk.DS.Geometry.Point", "Protogeometry.dll"); elementResolver.AddToResolutionMap("Autodesk.DS.Geometry.Point", "Autodesk.DS.Geometry.Point", "Protogeometry.dll"); newNodes = ElementRewriter.RewriteElementNames(core.ClassTable, elementResolver, astNodes); Assert.AreEqual("p = Autodesk.DS.Geometry.Point.ByCoordinates(Autodesk.DS.Geometry.Point.ByCoordinates(x, y, z).X, y, z).X;\n", newNodes.ElementAt(0).ToString()); }
protected override bool UpdateValueCore(UpdateValueParams updateValueParams) { string name = updateValueParams.PropertyName; string value = updateValueParams.PropertyValue; ElementResolver workspaceElementResolver = updateValueParams.ElementResolver; if (name != "Code") { return(base.UpdateValueCore(updateValueParams)); } value = CodeBlockUtils.FormatUserText(value); //Since an empty Code Block Node should not exist, this checks for such instances. // If an empty Code Block Node is found, it is deleted. Since the creation and deletion of // an empty Code Block Node should not be recorded, this method also checks and removes // any unwanted recordings if (value == "") { Code = ""; } else { if (!value.Equals(Code)) { SetCodeContent(value, workspaceElementResolver); } } return(true); }
/// <summary> /// Matches the completion string with classes, including primitive types. /// </summary> /// <param name="stringToComplete"></param> /// <param name="resolver"></param> /// <returns></returns> internal IEnumerable <CompletionData> SearchTypes(string stringToComplete, ElementResolver resolver = null) { var completions = new List <CompletionData>(); var partialName = stringToComplete.ToLower(); // Add matching Classes var classMirrorGroups = StaticMirror.GetAllTypes(core) .Where(x => !x.IsHiddenInLibrary && x.Alias.ToLower().StartsWith(partialName)) .GroupBy(x => x.Alias); // For those class names that have collisions (same alias), list // their fully qualified names in completion window. foreach (var classMirrorGroup in classMirrorGroups) { bool useFullyQualifiedName = classMirrorGroup.Count() > 1; foreach (var classMirror in classMirrorGroup) { var completionData = CompletionData.ConvertMirrorToCompletionData( classMirror, useFullyQualifiedName, resolver); completions.Add(completionData); } } return(completions); }
public void LookupResolvedName_FromCompiler_RewriteAst() { string code = @"import (""FFITarget.dll"");"; var mirror = thisTest.RunScriptSource(code); var testCore = thisTest.GetTestCore(); var astNodes = CoreUtils.BuildASTList(testCore, "d = ElementResolverTarget.ElementResolverTarget();"); var astNode = astNodes[0]; var elementResolver = new ElementResolver(); var elementRewriter = new ElementRewriter(testCore.ClassTable); elementRewriter.LookupResolvedNameAndRewriteAst(elementResolver, ref astNode); Assert.AreEqual("d = FFITarget.ElementResolverTarget.ElementResolverTarget();\n", astNode.ToString()); // Add verification for contents of element resolver resolution map Assert.AreEqual(1, elementResolver.ResolutionMap.Count); var assembly = elementResolver.LookupAssemblyName("ElementResolverTarget"); var resolvedName = elementResolver.LookupResolvedName("ElementResolverTarget"); Assert.AreEqual("FFITarget.dll", assembly); Assert.AreEqual("FFITarget.ElementResolverTarget", resolvedName); }
public void LookupResolvedName_ForPartialTypedIdentifier_RewriteAst() { var astNodes = CoreUtils.BuildASTList(core, "p : Autodesk.Point;"); var elementResolver = new ElementResolver(); elementResolver.AddToResolutionMap("Autodesk.Point", "Autodesk.DS.Geometry.Point", "Protogeometry.dll"); var newNodes = ElementRewriter.RewriteElementNames(core.ClassTable, elementResolver, astNodes); Assert.AreEqual("p : Autodesk.DS.Geometry.Point", newNodes.ElementAt(0).ToString()); astNodes = CoreUtils.BuildASTList(core, "p : Autodesk.DS.Point;"); elementResolver = new ElementResolver(); elementResolver.AddToResolutionMap("Autodesk.DS.Point", "Autodesk.DS.Geometry.Point", "Protogeometry.dll"); ElementRewriter.RewriteElementNames(core.ClassTable, elementResolver, astNodes); Assert.AreEqual("p : Autodesk.DS.Geometry.Point", newNodes.ElementAt(0).ToString()); astNodes = CoreUtils.BuildASTList(core, "p : Autodesk.DS.Geometry.Point;"); elementResolver = new ElementResolver(); elementResolver.AddToResolutionMap("Autodesk.DS.Geometry.Point", "Autodesk.DS.Geometry.Point", "Protogeometry.dll"); ElementRewriter.RewriteElementNames(core.ClassTable, elementResolver, astNodes); Assert.AreEqual("p : Autodesk.DS.Geometry.Point", newNodes.ElementAt(0).ToString()); }
public void LookupResolvedName_ForGlobalClass_RewriteAst() { const string code = @"import (""FFITarget.dll"");"; var mirror = thisTest.RunScriptSource(code); var testCore = thisTest.GetTestCore(); var astNodes = CoreUtils.BuildASTList(testCore, "a = GlobalClass.GlobalClass(a);"); var elementResolver = new ElementResolver(); var newNodes = ElementRewriter.RewriteElementNames(testCore.ClassTable, elementResolver, astNodes).ToList(); Assert.AreEqual("a = GlobalClass.GlobalClass(a);\n", newNodes[0].ToString()); astNodes = CoreUtils.BuildASTList(testCore, "a : GlobalClass;"); newNodes = ElementRewriter.RewriteElementNames(testCore.ClassTable, elementResolver, astNodes).ToList(); Assert.AreEqual("a : GlobalClass", newNodes[0].ToString()); // Add verification for contents of element resolver resolution map Assert.AreEqual(1, elementResolver.ResolutionMap.Count); var assembly = elementResolver.LookupAssemblyName("GlobalClass"); var resolvedName = elementResolver.LookupResolvedName("GlobalClass"); Assert.AreEqual("FFITarget.dll", assembly); Assert.AreEqual("GlobalClass", resolvedName); }
public CodeBlockNodeModel(LibraryServices libraryServices) { ArgumentLacing = LacingStrategy.Disabled; this.libraryServices = libraryServices; this.libraryServices.LibraryLoaded += LibraryServicesOnLibraryLoaded; this.ElementResolver = new ElementResolver(); }
public void LookupResolvedName_ForAssociativeBlock_RewriteAst() { var code = "c = [Associative]" + "{" + " a = [1, 2, 3, 4];" + " b = Autodesk.Point.ByCoordinates(a);" + " return = b;" + "}"; var elementResolver = new ElementResolver(); elementResolver.AddToResolutionMap("Autodesk.Point", "Autodesk.DesignScript.Geometry.Point", "Protogeometry.dll"); var astNodes = CoreUtils.BuildASTList(core, code); var newNodes = ElementRewriter.RewriteElementNames(core.ClassTable, elementResolver, astNodes).ToList(); var lbn = ((BinaryExpressionNode)newNodes[0]).RightNode as LanguageBlockNode; Assert.IsNotNull(lbn); var cbn = lbn.CodeBlockNode as CodeBlockNode; Assert.IsNotNull(cbn); Assert.AreEqual("b = Autodesk.DesignScript.Geometry.Point.ByCoordinates(a);\n", cbn.Body[1].ToString()); }
/// <summary> /// Matches the completion string with classes, including primitive types. /// </summary> /// <param name="stringToComplete"></param> /// <param name="resolver"></param> /// <returns></returns> internal IEnumerable <CompletionData> SearchTypes(string stringToComplete, ElementResolver resolver = null) { var completions = new List <CompletionData>(); AddTypesToCompletionData(stringToComplete, completions, resolver); return(completions); }
public ParseParam(System.Guid postfixGuid, System.String code, ElementResolver elementResolver) { this.PostfixGuid = postfixGuid; this.OriginalCode = code; this.ElementResolver = elementResolver; this.parsedNodes = new List <AssociativeNode>(); this.commentNodes = new List <AssociativeNode>(); this.errors = new List <BuildData.ErrorEntry>(); this.warnings = new List <BuildData.WarningEntry>(); }
public void LookupResolvedName_ForGlobalFunction_RewriteAst() { var astNodes = CoreUtils.BuildASTList(core, "a = Flatten(a).DifferenceAll(Flatten(b));"); var elementResolver = new ElementResolver(); var newNodes = ElementRewriter.RewriteElementNames(core.ClassTable, elementResolver, astNodes).ToList(); Assert.AreEqual("a = Flatten(a).DifferenceAll(Flatten(b));\n", newNodes[0].ToString()); }
public void ReproMAGN3603() { string code = @"a = 1 + (2 * 3); b = (1 + 2) * 3; c = 1 + 2 * 3;"; ElementResolver elementResolver = new ElementResolver(); ParseParam parseParam = new ParseParam(Guid.NewGuid(), code, elementResolver); Assert.IsTrue(CompilerUtils.PreCompileCodeBlock(thisTest.CreateTestCore(), ref parseParam)); Assert.IsTrue(parseParam.ParsedNodes != null && parseParam.ParsedNodes.Count() > 0); var parsedNode = parseParam.ParsedNodes.ElementAt(0); BinaryExpressionNode n = parsedNode as BinaryExpressionNode; FunctionCallNode funcCall = n.RightNode as FunctionCallNode; Assert.IsTrue(n != null && funcCall != null); IdentifierNode identNode = funcCall.Function as IdentifierNode; Assert.IsTrue(identNode != null && identNode.Value == "%add"); var args = funcCall.FormalArguments; Assert.IsTrue(args.Count == 2); Assert.IsTrue(args[0] is IntNode); FunctionCallNode nestedFuncCall = args[1] as FunctionCallNode; Assert.IsTrue(nestedFuncCall != null && (nestedFuncCall.Function as IdentifierNode).Value == "%mul"); parsedNode = parseParam.ParsedNodes.ElementAt(1); n = parsedNode as BinaryExpressionNode; funcCall = n.RightNode as FunctionCallNode; Assert.IsTrue(n != null && funcCall != null); identNode = funcCall.Function as IdentifierNode; Assert.IsTrue(identNode != null && identNode.Value == "%mul"); args = funcCall.FormalArguments; Assert.IsTrue(args.Count == 2); Assert.IsTrue(args[1] is IntNode); nestedFuncCall = args[0] as FunctionCallNode; Assert.IsTrue(nestedFuncCall != null && (nestedFuncCall.Function as IdentifierNode).Value == "%add"); parsedNode = parseParam.ParsedNodes.ElementAt(2); n = parsedNode as BinaryExpressionNode; funcCall = n.RightNode as FunctionCallNode; Assert.IsTrue(n != null && funcCall != null); identNode = funcCall.Function as IdentifierNode; Assert.IsTrue(identNode != null && identNode.Value == "%add"); args = funcCall.FormalArguments; Assert.IsTrue(args.Count == 2); Assert.IsTrue(args[0] is IntNode); nestedFuncCall = args[1] as FunctionCallNode; Assert.IsTrue(nestedFuncCall != null && (nestedFuncCall.Function as IdentifierNode).Value == "%mul"); }
private static string GetShortClassName(ClassMirror mirror, ElementResolver resolver) { var shortName = string.Empty; if (resolver != null) { shortName = resolver.LookupShortName(mirror.ClassName); } return(string.IsNullOrEmpty(shortName) ? mirror.Alias : shortName); }
public void LookupResolvedName_FromElementResolver_RewriteAst() { var astNodes = CoreUtils.BuildASTList(core, "p = Point.ByCoordinates(0,0,0);"); var elementResolver = new ElementResolver(); elementResolver.AddToResolutionMap("Point", "Autodesk.DS.Geometry.Point", "Protogeometry.dll"); var newNodes = ElementRewriter.RewriteElementNames(core.ClassTable, elementResolver, astNodes); Assert.AreEqual("p = Autodesk.DS.Geometry.Point.ByCoordinates(0, 0, 0);\n", newNodes.ElementAt(0).ToString()); }
public CustomNodeWorkspaceModel( string name, string category, string description, NodeFactory factory, IEnumerable <NodeModel> e, IEnumerable <NoteModel> n, double x, double y, Guid customNodeId, ElementResolver elementResolver, string fileName = "") : base(name, e, n, x, y, factory, elementResolver, fileName) { CustomNodeId = customNodeId; HasUnsavedChanges = false; Category = category; Description = description; PropertyChanged += OnPropertyChanged; }
public Symbol() { OutPortData.Add(new PortData("", Properties.Resources.ToolTipSymbol)); RegisterAllPorts(); ArgumentLacing = LacingStrategy.Disabled; InputSymbol = String.Empty; ElementResolver = new ElementResolver(); }
/// <summary> /// Initializes a new instance of the <see cref="HomeWorkspaceModel"/> class /// by given information about it and specified item collections /// </summary> /// <param name="engine"><see cref="EngineController"/> object assosiated with this home workspace /// to coordinate the interactions between some DesignScript sub components.</param> /// <param name="scheduler"><see cref="DynamoScheduler"/> object to add tasks in queue to execute</param> /// <param name="factory">Node factory to create nodes</param> /// <param name="traceData">Preloaded trace data</param> /// <param name="nodes">Node collection of the workspace</param> /// <param name="notes">Note collection of the workspace</param> /// <param name="annotations">Group collection of the workspace</param> /// <param name="presets">Preset collection of the workspace</param> /// <param name="elementResolver">ElementResolver responsible for resolving /// a partial class name to its fully resolved name</param> /// <param name="info">Information for creating custom node workspace</param> /// <param name="verboseLogging">Indicates if detailed descriptions should be logged</param> /// <param name="isTestMode">Indicates if current code is running in tests</param> public HomeWorkspaceModel(EngineController engine, DynamoScheduler scheduler, NodeFactory factory, IEnumerable <KeyValuePair <Guid, List <CallSite.RawTraceData> > > traceData, IEnumerable <NodeModel> nodes, IEnumerable <NoteModel> notes, IEnumerable <AnnotationModel> annotations, IEnumerable <PresetModel> presets, ElementResolver resolver, WorkspaceInfo info, bool verboseLogging, bool isTestMode) : base(nodes, notes, annotations, info, factory, presets, resolver) { Debug.WriteLine("Creating a home workspace..."); EvaluationCount = 0; // This protects the user from a file that might have crashed during // its last run. As a side effect, this also causes all files set to // run auto but lacking the HasRunWithoutCrash flag to run manually. if (info.RunType == RunType.Automatic && !info.HasRunWithoutCrash) { info.RunType = RunType.Manual; } RunSettings = new RunSettings(info.RunType, info.RunPeriod); PreloadedTraceData = traceData; this.scheduler = scheduler; this.verboseLogging = verboseLogging; IsTestMode = isTestMode; EngineController = engine; this.ExtensionData = new List <ExtensionData>(); // The first time the preloaded trace data is set, we cache // the data as historical. This will be used after the initial // run of this workspace, when the PreloadedTraceData has been // nulled, to check for node deletions and reconcile the trace data. // We do a deep copy of this data because the PreloadedTraceData is // later set to null before the graph update. var copiedData = new List <KeyValuePair <Guid, List <CallSite.RawTraceData> > >(); foreach (var kvp in PreloadedTraceData) { List <CallSite.RawTraceData> callSiteTraceData = new List <CallSite.RawTraceData>(); callSiteTraceData.AddRange(kvp.Value); copiedData.Add(new KeyValuePair <Guid, List <CallSite.RawTraceData> >(kvp.Key, callSiteTraceData)); } historicalTraceData = copiedData; }
public void SetCodeContent(string newCode, ElementResolver workspaceElementResolver) { if (code != null && code.Equals(newCode)) { return; } if (newCode == null) { code = null; } else { string errorMessage = string.Empty; string warningMessage = string.Empty; var inportConnections = new OrderedDictionary(); var outportConnections = new OrderedDictionary(); // disable node modification evnets while mutating the code this.OnRequestSilenceModifiedEvents(true); //Save the connectors so that we can recreate them at the correct positions SaveAndDeleteConnectors(inportConnections, outportConnections); code = newCode; ProcessCode(ref errorMessage, ref warningMessage, workspaceElementResolver); //Recreate connectors that can be reused LoadAndCreateConnectors(inportConnections, outportConnections); RaisePropertyChanged("Code"); ReportPosition(); ClearRuntimeError(); if (!string.IsNullOrEmpty(errorMessage)) { Error(errorMessage); } else if (!string.IsNullOrEmpty(warningMessage)) { Warning(warningMessage); } this.OnRequestSilenceModifiedEvents(false); // Mark node for update OnNodeModified(); } }
public CodeBlockNodeModel(string userCode, Guid guid, double xPos, double yPos, LibraryServices libraryServices, ElementResolver resolver) { ArgumentLacing = LacingStrategy.Disabled; X = xPos; Y = yPos; this.libraryServices = libraryServices; this.libraryServices.LibraryLoaded += LibraryServicesOnLibraryLoaded; this.ElementResolver = resolver; code = userCode; GUID = guid; ShouldFocus = false; ProcessCodeDirect(); }
public void LookupResolvedName_FromElementResolver_RewriteAst2() { // TODO pratapa: Return to fix test with Dictionary.ValueAtKey method var astNodes = CoreUtils.BuildASTList(core, "p = Geometry.Point.ByCoordinates(0,0,0)[0];"); var elementResolver = new ElementResolver(); elementResolver.AddToResolutionMap("Point", "Autodesk.DS.Geometry.Point", "Protogeometry.dll"); var newNodes = ElementRewriter.RewriteElementNames(core.ClassTable, elementResolver, astNodes); Assert.AreEqual("p = Autodesk.DS.Geometry.Point.ByCoordinates(0, 0, 0)[0];\n", newNodes.ElementAt(0).ToString()); }
public CustomNodeWorkspaceModel( string name, string category, string description, double x, double y, Guid customNodeId, NodeFactory factory, ElementResolver elementResolver, string fileName = "") : this( name, category, description, factory, Enumerable.Empty <NodeModel>(), Enumerable.Empty <NoteModel>(), x, y, customNodeId, elementResolver, fileName) { }
public HomeWorkspaceModel(Guid guid, EngineController engine, DynamoScheduler scheduler, NodeFactory factory, IEnumerable <KeyValuePair <Guid, List <CallSite.RawTraceData> > > traceData, IEnumerable <NodeModel> nodes, IEnumerable <NoteModel> notes, IEnumerable <AnnotationModel> annotations, IEnumerable <PresetModel> presets, ElementResolver resolver, WorkspaceInfo info, bool verboseLogging) : this(engine, scheduler, factory, traceData, nodes, notes, annotations, presets, resolver, info, verboseLogging) { Guid = guid; }
protected override bool UpdateValueCore(UpdateValueParams updateValueParams) { string name = updateValueParams.PropertyName; string value = updateValueParams.PropertyValue; workspaceElementResolver = updateValueParams.ElementResolver; if (name == "InputSymbol") { InputSymbol = value; return(true); // UpdateValueCore handled. } return(base.UpdateValueCore(updateValueParams)); }
protected override void DeserializeCore(XmlElement nodeElement, SaveContext context) { base.DeserializeCore(nodeElement, context); var helper = new XmlElementHelper(nodeElement); shouldFocus = helper.ReadBoolean("ShouldFocus"); code = helper.ReadString("CodeText"); // Lookup namespace resolution map if available and initialize new instance of ElementResolver var resolutionMap = CodeBlockUtils.DeserializeElementResolver(nodeElement); ElementResolver = new ElementResolver(resolutionMap); ProcessCodeDirect(); }
public void TestUnboundIdentifierInUnnamedSignedExpression() { string code = @"a*-1;"; ElementResolver elementResolver = new ElementResolver(); ParseParam parseParam = new ParseParam(Guid.NewGuid(), code, elementResolver); Assert.IsTrue(CompilerUtils.PreCompileCodeBlock(thisTest.CreateTestCore(), ref parseParam)); Assert.IsTrue(parseParam.ParsedNodes != null && parseParam.ParsedNodes.Any()); var inputIdentifier = parseParam.UnboundIdentifiers; Assert.AreEqual(1, inputIdentifier.Count); Assert.AreEqual("a", inputIdentifier.ElementAt(0).Value); }
public HomeWorkspaceModel( EngineController engine, DynamoScheduler scheduler, NodeFactory factory, IEnumerable <KeyValuePair <Guid, List <string> > > traceData, IEnumerable <NodeModel> e, IEnumerable <NoteModel> n, double x, double y, bool verboseLogging, bool isTestMode, ElementResolver elementResolver, string fileName = "") : base("Home", e, n, x, y, factory, elementResolver, fileName) { RunEnabled = true; PreloadedTraceData = traceData; this.scheduler = scheduler; VerboseLogging = verboseLogging; ResetEngine(engine); IsTestMode = isTestMode; }
protected override void DeserializeCore(XmlElement nodeElement, SaveContext context) { base.DeserializeCore(nodeElement, context); foreach (var subNode in nodeElement.ChildNodes.Cast <XmlNode>() .Where(subNode => subNode.Name == "Symbol")) { InputSymbol = subNode.Attributes[0].Value; } ArgumentLacing = LacingStrategy.Disabled; var resolutionMap = CodeBlockUtils.DeserializeElementResolver(nodeElement); elementResolver = new ElementResolver(resolutionMap); }
public HomeWorkspaceModel(EngineController engine, DynamoScheduler scheduler, NodeFactory factory, IEnumerable <KeyValuePair <Guid, List <CallSite.RawTraceData> > > traceData, IEnumerable <NodeModel> nodes, IEnumerable <NoteModel> notes, IEnumerable <AnnotationModel> annotations, IEnumerable <PresetModel> presets, ElementResolver resolver, WorkspaceInfo info, bool verboseLogging, bool isTestMode) : base(nodes, notes, annotations, info, factory, presets, resolver) { InitializeHomeWorkspace(engine, traceData, scheduler, info, verboseLogging, isTestMode); }
/// <summary> /// Returns the list of function signatures of all overloads of a given method /// </summary> /// <param name="code"> code being typed in code block </param> /// <param name="functionName"> given method name for which signature is queried </param> /// <param name="functionPrefix"> class name in case of constructor or static method, OR /// declared instance variable on which method is invoked </param> /// <param name="resolver"></param> /// <returns> list of method overload signatures </returns> internal IEnumerable <CompletionData> GetFunctionSignatures(string code, string functionName, string functionPrefix, ElementResolver resolver = null) { IEnumerable <MethodMirror> candidates = null; // if function is global, search for function in Built-ins if (string.IsNullOrEmpty(functionPrefix)) { return(StaticMirror.GetOverloadsOnBuiltIns(core, functionName). Select(x => { return new CompletionData(x.MethodName, CompletionData.CompletionType.Method) { Stub = x.ToString() }; })); } // Determine if the function prefix is a class name if (resolver != null) { functionPrefix = resolver.LookupResolvedName(functionPrefix) ?? functionPrefix; } var type = GetClassType(functionPrefix); if (type != null) { candidates = type.GetOverloadsOnType(functionName); } // If not of class type else { // Check if the function prefix is a typed identifier string typeName = CodeCompletionParser.GetVariableType(code, functionPrefix); if (typeName != null) { type = GetClassType(typeName); } if (type != null) { candidates = type.GetOverloadsOnInstance(functionName); } } return(candidates.Select(x => CompletionData.ConvertMirrorToCompletionData(x))); }