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)));
}
