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