public void CopyResolutionMap(ElementResolver otherResolver)
{
foreach (var e in otherResolver.ResolutionMap.Where(e => !resolutionMap.ContainsKey(e.Key)))
{
resolutionMap.Add(e);
}
}
/// <summary>
/// Lookup namespace resolution map to substitute
/// partial classnames with their fully qualified names in ASTs.
/// If partial class is not found in map,
/// update ResolutionMap with fully resolved name from compiler.
/// </summary>
/// <param name="classTable"></param>
/// <param name="elementResolver"></param>
/// <param name="astNodes"> parent AST node </param>
/// <param name="handler"></param>
public static IEnumerable <Node> RewriteElementNames(ClassTable classTable,
ElementResolver elementResolver, IEnumerable <Node> astNodes, SymbolConflictWarningHandler handler = null)
{
var elementRewriter = new ElementRewriter(classTable, handler, elementResolver);
return(astNodes.OfType <AssociativeNode>().Select(astNode => astNode.Accept(elementRewriter)).Cast <Node>().ToList());
}
public void CopyResolutionMap(ElementResolver otherResolver)
{
foreach (var e in otherResolver.ResolutionMap.Where(e => !resolutionMap.ContainsKey(e.Key)))
{
resolutionMap.Add(e);
}
}
public CodeBlockNodeModel(LibraryServices libraryServices)
{
ArgumentLacing = LacingStrategy.Disabled;
this.libraryServices = libraryServices;
this.libraryServices.LibraryLoaded += LibraryServicesOnLibraryLoaded;
this.ElementResolver = new ElementResolver();
}
/// <summary>
/// Determines if the completion string is a valid type and
/// enumerates the list of completion members on the type
/// </summary>
/// <param name="code"> code typed in the code block </param>
/// <param name="stringToComplete"> Class name or declared variable </param>
/// <param name="resolver"></param>
/// <returns> list of method and property members of the type </returns>
internal IEnumerable<CompletionData> GetCompletionsOnType(string code, string stringToComplete, ElementResolver resolver = null)
{
IEnumerable<StaticMirror> members = null;
if (resolver != null)
{
stringToComplete = resolver.LookupResolvedName(stringToComplete) ?? stringToComplete;
}
// Determine if the string to be completed is a class
var type = GetClassType(stringToComplete);
if (type != null)
{
members = type.GetMembers();
}
// If not of class type
else
{
// Check if the string to be completed is a declared variable
string typeName = CodeCompletionParser.GetVariableType(code, stringToComplete);
if (typeName != null)
type = GetClassType(typeName);
if (type != null)
{
members = type.GetInstanceMembers();
}
}
return members.Select(x => CompletionData.ConvertMirrorToCompletionData(x));
}
/// <summary>
/// Lookup namespace resolution map to substitute
/// partial classnames with their fully qualified names in ASTs.
/// If partial class is not found in map,
/// update ResolutionMap with fully resolved name from compiler.
/// </summary>
/// <param name="classTable"></param>
/// <param name="elementResolver"></param>
/// <param name="astNodes"> parent AST node </param>
public static IEnumerable <Node> RewriteElementNames(ClassTable classTable,
ElementResolver elementResolver, IEnumerable <Node> astNodes)
{
var elementRewriter = new ElementRewriter(classTable, elementResolver);
return(astNodes.OfType <AssociativeNode>().Select(astNode => astNode.Accept(elementRewriter)).Cast <Node>().ToList());
}
private static IEnumerable<NodeModel> LoadNodesFromXml(XmlDocument xmlDoc, NodeFactory nodeFactory, ElementResolver resolver)
{
XmlNodeList elNodes = xmlDoc.GetElementsByTagName("Elements");
if (elNodes.Count == 0)
elNodes = xmlDoc.GetElementsByTagName("dynElements");
XmlNode elNodesList = elNodes[0];
return from XmlElement elNode in elNodesList.ChildNodes
select LoadNodeFromXml(elNode, SaveContext.File, nodeFactory, resolver);
}
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());
}
internal void LookupResolvedNameAndRewriteAst(ElementResolver elementResolver,
ref AssociativeNode astNode)
{
Debug.Assert(elementResolver != null);
// Get partial class identifier/identifier lists
var classIdentifiers = GetClassIdentifiers(astNode);
var resolvedNames = new Queue <string>();
foreach (var identifier in classIdentifiers)
{
string partialName = string.Empty;
var identifierList = identifier as IdentifierListNode;
if (identifierList != null)
{
partialName = CoreUtils.GetIdentifierExceptMethodName(identifierList);
}
else
{
partialName = identifier.Name;
}
var resolvedName = elementResolver.LookupResolvedName(partialName);
if (string.IsNullOrEmpty(resolvedName))
{
// If namespace resolution map does not contain entry for partial name,
// back up on compiler to resolve the namespace from partial name
var matchingClasses = CoreUtils.GetResolvedClassName(classTable, CoreUtils.CreateNodeFromString(partialName));
if (matchingClasses.Length == 1)
{
resolvedName = matchingClasses[0];
var assemblyName = CoreUtils.GetAssemblyFromClassName(classTable, resolvedName);
elementResolver.AddToResolutionMap(partialName, resolvedName, assemblyName);
}
else
{
// Class name could not be resolved - Possible namespace conflict
// This will be reported subsequently in the pre-compilation stage if there's a conflict
// Enter an empty resolved name to the list and continue
resolvedNames.Enqueue(string.Empty);
continue;
}
}
resolvedNames.Enqueue(resolvedName);
}
if (resolvedNames.Any())
{
RewriteAstWithResolvedName(ref astNode, resolvedNames);
}
}
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");
}
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.ElementResolver = resolver;
code = userCode;
GUID = guid;
ShouldFocus = false;
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);
}
/// <summary>
/// Lookup namespace resolution map to substitute
/// partial classnames with their fully qualified names in ASTs.
/// If partial class is not found in map,
/// update ResolutionMap with fully resolved name from compiler.
/// </summary>
/// <param name="classTable"></param>
/// <param name="elementResolver"></param>
/// <param name="astNodes"> parent AST node </param>
public static void RewriteElementNames(ClassTable classTable,
ElementResolver elementResolver, IEnumerable <Node> astNodes)
{
var elementRewriter = new ElementRewriter(classTable);
foreach (var node in astNodes)
{
var astNode = node as AssociativeNode;
if (astNode == null)
{
continue;
}
elementRewriter.LookupResolvedNameAndRewriteAst(elementResolver, ref astNode);
}
}
public CustomNodeWorkspaceModel(
NodeFactory factory,
IEnumerable<NodeModel> e,
IEnumerable<NoteModel> n,
IEnumerable<AnnotationModel> a,
IEnumerable<PresetModel> presets,
ElementResolver elementResolver,
WorkspaceInfo info)
: base(e, n,a, info, factory,presets, elementResolver)
{
HasUnsavedChanges = false;
CustomNodeId = Guid.Parse(info.ID);
Category = info.Category;
Description = info.Description;
PropertyChanged += OnPropertyChanged;
}
public CustomNodeWorkspaceModel(
NodeFactory factory,
IEnumerable<NodeModel> nodes,
IEnumerable<NoteModel> notes,
IEnumerable<AnnotationModel> annotations,
IEnumerable<PresetModel> presets,
ElementResolver elementResolver,
WorkspaceInfo info)
: base(nodes, notes,annotations, info, factory,presets, elementResolver)
{
HasUnsavedChanges = false;
CustomNodeId = Guid.Parse(info.ID);
Category = info.Category;
Description = info.Description;
IsVisibleInDynamoLibrary = info.IsVisibleInDynamoLibrary;
PropertyChanged += OnPropertyChanged;
}
private void VerifyResult(string fullName, string partialName, string functionOrProperty, bool isProperty = false)
{
var testCore = thisTest.GetTestCore();
var astNodes = CoreUtils.BuildASTList(testCore, string.Format("d = {0}.{1};", partialName, functionOrProperty));
var elementResolver = new ElementResolver();
var newNodes = ElementRewriter.RewriteElementNames(testCore.ClassTable, elementResolver, astNodes);
Assert.AreEqual(string.Format("d = {0}.{1};\n", fullName, functionOrProperty), newNodes.ElementAt(0).ToString());
if (!isProperty)
{
// Add verification for contents of element resolver resolution map
var assembly = elementResolver.LookupAssemblyName(partialName);
var resolvedName = elementResolver.LookupResolvedName(partialName);
Assert.AreEqual("FFITarget.dll", assembly);
Assert.AreEqual(fullName, resolvedName);
}
}
public CustomNodeWorkspaceModel(
NodeFactory factory,
IEnumerable<NodeModel> e,
IEnumerable<NoteModel> n,
IEnumerable<AnnotationModel> a,
WorkspaceInfo info,
ElementResolver elementResolver = null)
: base(e, n,a,info, factory)
{
HasUnsavedChanges = false;
CustomNodeId = Guid.Parse(info.ID);
Category = info.Category;
Description = info.Description;
if (elementResolver != null)
{
ElementResolver.CopyResolutionMap(elementResolver);
}
PropertyChanged += OnPropertyChanged;
}
public void LookupResolvedName_FromCompiler_RewriteAst()
{
const string code = @"import (""FFITarget.dll"");";
var mirror = thisTest.RunScriptSource(code);
var testCore = thisTest.GetTestCore();
var astNodes = CoreUtils.BuildASTList(testCore, "d = ElementResolverTarget.ElementResolverTarget();");
var elementResolver = new ElementResolver();
var newNodes = ElementRewriter.RewriteElementNames(testCore.ClassTable, elementResolver, astNodes);
Assert.AreEqual("d = FFITarget.ElementResolverTarget.ElementResolverTarget();\n", newNodes.ElementAt(0).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);
}
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();
}
protected WorkspaceModel(
IEnumerable<NodeModel> e,
IEnumerable<NoteModel> n,
IEnumerable<AnnotationModel> a,
WorkspaceInfo info,
NodeFactory factory,
IEnumerable<PresetModel> presets)
{
guid = Guid.NewGuid();
nodes = new ObservableCollection<NodeModel>(e);
notes = new ObservableCollection<NoteModel>(n);
annotations = new ObservableCollection<AnnotationModel>(a);
// Set workspace info from WorkspaceInfo object
Name = info.Name;
X = info.X;
Y = info.Y;
FileName = info.FileName;
Zoom = info.Zoom;
HasUnsavedChanges = false;
LastSaved = DateTime.Now;
WorkspaceVersion = AssemblyHelper.GetDynamoVersion();
undoRecorder = new UndoRedoRecorder(this);
NodeFactory = factory;
this.presets = new List<PresetModel>(presets);
// Update ElementResolver from nodeGraph.Nodes (where node is CBN)
ElementResolver = new ElementResolver();
foreach (var node in nodes)
{
RegisterNode(node);
var cbn = node as CodeBlockNodeModel;
if (cbn != null && cbn.ElementResolver != null)
{
ElementResolver.CopyResolutionMap(cbn.ElementResolver);
}
}
foreach (var connector in Connectors)
RegisterConnector(connector);
SetModelEventOnAnnotation();
}
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 HomeWorkspaceModel(
EngineController engine,
DynamoScheduler scheduler,
NodeFactory factory,
IEnumerable<KeyValuePair<Guid, List<string>>> traceData,
IEnumerable<NodeModel> e,
IEnumerable<NoteModel> n,
IEnumerable<AnnotationModel> a,
IEnumerable<PresetModel> presets,
ElementResolver resolver,
WorkspaceInfo info,
bool verboseLogging,
bool isTestMode)
: base(e, n,a, info, factory,presets, resolver)
{
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;
// 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<string>>>();
foreach (var kvp in PreloadedTraceData)
{
var strings = kvp.Value.Select(string.Copy).ToList();
copiedData.Add(new KeyValuePair<Guid, List<string>>(kvp.Key, strings));
}
historicalTraceData = copiedData;
}
internal void ResetWorkspace()
{
ElementResolver = new ElementResolver();
ResetWorkspaceCore();
}
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_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_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 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());
}
/// <summary>
/// Creates and initializes a NodeModel from its Xml representation.
/// </summary>
/// <param name="elNode">XmlElement for a NodeModel.</param>
/// <param name="context">The serialization context for initialization.</param>
/// <param name="nodeFactory">A NodeFactory, to be used to create the node.</param>
/// <returns></returns>
public static NodeModel LoadNodeFromXml(
XmlElement elNode, SaveContext context, NodeFactory nodeFactory, ElementResolver resolver)
{
return nodeFactory.CreateNodeFromXml(elNode, context, resolver);
}
public ElementRewriter(ClassTable classTable, SymbolConflictWarningHandler warningHandler, ElementResolver resolver = null)
{
this.classTable = classTable;
this.symbolConflictHandler = warningHandler;
this.elementResolver = resolver ?? new ElementResolver();
}
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();
//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);
// Mark node for update
OnNodeModified();
}
}
public void LookupResolvedName_ForFunctionDefinition_RewriteAst()
{
var code =
"def foo()" +
"{" +
" return = Autodesk.DesignScript.Geometry.Point.ByCoordinates();" +
"}" +
"a = foo();";
var elementResolver = new ElementResolver();
elementResolver.AddToResolutionMap("Point", "Autodesk.DesignScript.Geometry.Point", "Protogeometry.dll");
var astNodes = CoreUtils.BuildASTList(core, code);
var newNodes = ElementRewriter.RewriteElementNames(core.ClassTable, elementResolver, astNodes).ToList();
Assert.AreEqual("return = Autodesk.DesignScript.Geometry.Point.ByCoordinates();\n",
((FunctionDefinitionNode)newNodes[0]).FunctionBody.ToString());
}
private void ProcessCode(ref string errorMessage, ref string warningMessage,
ElementResolver workspaceElementResolver = null)
{
code = CodeBlockUtils.FormatUserText(code);
codeStatements.Clear();
if (string.IsNullOrEmpty(Code))
previewVariable = null;
try
{
// During loading of CBN from file, the elementResolver from the workspace is unavailable
// in which case, a local copy of the ER obtained from the CBN is used
var resolver = workspaceElementResolver ?? this.ElementResolver;
var parseParam = new ParseParam(GUID, code, resolver);
if (CompilerUtils.PreCompileCodeBlock(libraryServices.LibraryManagementCore, ref parseParam))
{
if (parseParam.ParsedNodes != null)
{
// Create an instance of statement for each code statement written by the user
foreach (var parsedNode in parseParam.ParsedNodes)
{
// Create a statement variable from the generated nodes
codeStatements.Add(Statement.CreateInstance(parsedNode));
}
SetPreviewVariable(parseParam.ParsedNodes);
}
}
if (parseParam.Errors != null && parseParam.Errors.Any())
{
errorMessage = string.Join("\n", parseParam.Errors.Select(m => m.Message));
ProcessError();
CreateInputOutputPorts();
return;
}
if (parseParam.Warnings != null)
{
// Unbound identifiers in CBN will have input slots.
//
// To check function redefinition, we need to check other
// CBN to find out if it has been defined yet. Now just
// skip this warning.
var warnings =
parseParam.Warnings.Where(
w =>
w.ID != WarningID.kIdUnboundIdentifier
&& w.ID != WarningID.kFunctionAlreadyDefined);
if (warnings.Any())
{
warningMessage = string.Join("\n", warnings.Select(m => m.Message));
}
}
if (parseParam.UnboundIdentifiers != null)
{
inputIdentifiers = new List<string>();
inputPortNames = new List<string>();
foreach (var kvp in parseParam.UnboundIdentifiers)
{
inputIdentifiers.Add(kvp.Value);
inputPortNames.Add(kvp.Key);
}
}
else
{
inputIdentifiers.Clear();
inputPortNames.Clear();
}
}
catch (Exception e)
{
errorMessage = e.Message;
previewVariable = null;
ProcessError();
return;
}
// Set the input and output ports based on the statements
CreateInputOutputPorts();
}
/// <summary>
///
/// </summary>
/// <param name="propertyName">Name of the property whose value is to be updated.
/// This parameter cannot be empty or null.</param>
/// <param name="propertyValue">Value of the named property whose value is to be
/// updated. This parameter can either be null or empty if the targeted property
/// allows such values.This value comes directly
/// from DynamoTextBox after user commits it. Overridden methods then use
/// a specific IValueConverter to turn this string into another data type
/// that it expects</param>
/// <param name="elementResolver">responsible for resolving class namespaces</param>
public UpdateValueParams(string propertyName, string propertyValue, ElementResolver elementResolver = null)
{
ElementResolver = elementResolver;
PropertyName = propertyName;
PropertyValue = propertyValue;
}
public CodeBlockNodeModel(string userCode, double xPos, double yPos, LibraryServices libraryServices, ElementResolver resolver)
: this(userCode, Guid.NewGuid(), xPos, yPos, libraryServices, resolver) { }
internal ElementRewriter(ClassTable classTable, ElementResolver resolver)
{
this.classTable = classTable;
this.elementResolver = resolver;
}
protected WorkspaceModel(
IEnumerable<NodeModel> nodes,
IEnumerable<NoteModel> notes,
IEnumerable<AnnotationModel> annotations,
WorkspaceInfo info,
NodeFactory factory,
IEnumerable<PresetModel> presets,
ElementResolver resolver)
{
guid = Guid.NewGuid();
this.nodes = new List<NodeModel>(nodes);
this.notes = new List<NoteModel>(notes);
this.annotations = new List<AnnotationModel>(annotations);
// Set workspace info from WorkspaceInfo object
Name = info.Name;
Description = info.Description;
X = info.X;
Y = info.Y;
FileName = info.FileName;
Zoom = info.Zoom;
HasUnsavedChanges = false;
LastSaved = DateTime.Now;
WorkspaceVersion = AssemblyHelper.GetDynamoVersion();
undoRecorder = new UndoRedoRecorder(this);
NodeFactory = factory;
this.presets = new List<PresetModel>(presets);
ElementResolver = resolver;
foreach (var node in this.nodes)
RegisterNode(node);
foreach (var connector in Connectors)
RegisterConnector(connector);
SetModelEventOnAnnotation();
}
public void LookupResolvedName_ForNestedNamespacesExpressionFromCompiler_RewriteAst()
{
const string code = @"import (""FFITarget.dll"");";
var mirror = thisTest.RunScriptSource(code);
var testCore = thisTest.GetTestCore();
string class1 = "NestedResolverTarget";
string class2 = "ElementResolverTarget";
string fullName1 = "FFITarget.NameSpaceA.NameSpaceB.NameSpaceC.NestedResolverTarget";
string fullName2 = "FFITarget.ElementResolverTarget";
var astNodes = CoreUtils.BuildASTList(testCore, string.Format("d = {0}.Property.Method({1}.Create().Property.Method({0}.Property.Property));", class1, class2));
var elementResolver = new ElementResolver();
var newNodes = ElementRewriter.RewriteElementNames(testCore.ClassTable, elementResolver, astNodes);
Assert.AreEqual(
string.Format("d = {0}.Property.Method({1}.Create().Property.Method({0}.Property.Property));\n", fullName1, fullName2),
newNodes.ElementAt(0).ToString());
// Add verification for contents of element resolver resolution map
var assembly = elementResolver.LookupAssemblyName(class2);
var resolvedName = elementResolver.LookupResolvedName(class2);
Assert.AreEqual("FFITarget.dll", assembly);
Assert.AreEqual(fullName2, resolvedName);
///////////////////////////////////////////////
astNodes = CoreUtils.BuildASTList(testCore, string.Format("d = {0}.Property.Method({1}.Create().Property.Method({0}.Property.Property));", fullName1, fullName2));
elementResolver = new ElementResolver();
newNodes = ElementRewriter.RewriteElementNames(testCore.ClassTable, elementResolver, astNodes);
Assert.AreEqual(
string.Format("d = {0}.Property.Method({1}.Create().Property.Method({0}.Property.Property));\n", fullName1, fullName2),
newNodes.ElementAt(0).ToString());
// Add verification for contents of element resolver resolution map
assembly = elementResolver.LookupAssemblyName(fullName2);
resolvedName = elementResolver.LookupResolvedName(fullName2);
Assert.AreEqual("FFITarget.dll", assembly);
Assert.AreEqual(fullName2, resolvedName);
}
