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_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_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()); }
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 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()); }
public void SkipResolvingName_ForPrimitiveTypedIdentifier_RetainAst() { var astNodes = CoreUtils.BuildASTList(core, "p : int;"); var newNodes = ElementRewriter.RewriteElementNames(core.ClassTable, new ElementResolver(), astNodes); Assert.AreEqual("p : int", 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_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 void GetClassIdentifiers_FromAst() { var astNodes = CoreUtils.BuildASTList(core, "d = Point.ByCoordinates(0, 0, pt.X + 5);"); var astNode = astNodes[0]; var elementRewriter = new ElementRewriter(null); var identifiers = elementRewriter.GetClassIdentifiers(astNode); var identifierListNodes = identifiers as IdentifierListNode[] ?? identifiers.ToArray(); Assert.AreEqual(2, identifierListNodes.Count()); Assert.AreEqual("pt.X", identifierListNodes.ElementAt(0).ToString()); Assert.AreEqual("Point.ByCoordinates(0, 0, (pt.X) + 5)", identifierListNodes.ElementAt(1).ToString()); }
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 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); }
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()); }
public void LookupResolvedName_ForTypedIdentifierFromCompiler_RewriteAst() { const string code = @"import (""FFITarget.dll"");"; var mirror = thisTest.RunScriptSource(code); var testCore = thisTest.GetTestCore(); var astNodes = CoreUtils.BuildASTList(testCore, "d : ElementResolverTarget;"); var elementResolver = new ElementResolver(); var newNodes = ElementRewriter.RewriteElementNames(testCore.ClassTable, elementResolver, astNodes); Assert.AreEqual("d : FFITarget.ElementResolverTarget", newNodes.ElementAt(0).ToString()); // Add verification for contents of element resolver resolution map var assembly = elementResolver.LookupAssemblyName("ElementResolverTarget"); var resolvedName = elementResolver.LookupResolvedName("ElementResolverTarget"); Assert.AreEqual("FFITarget.dll", assembly); Assert.AreEqual("FFITarget.ElementResolverTarget", resolvedName); }
public void LookupResolvedName_AfterAddingHiddenClass_DoNotRewriteAst() { const string code = @"import (""FFITarget.dll"");"; var mirror = thisTest.RunScriptSource(code); var core = thisTest.GetTestCore(); // Call method on class hidden in library. var astNodes = CoreUtils.BuildASTList(core, "p = C.DupTargetTest.DupTargetTest();"); var elementResolver = new ElementResolver(); var newNodes = ElementRewriter.RewriteElementNames(core.ClassTable, elementResolver, astNodes); // Assert for fully resolved name of hidden class returned from ElementRewriter Assert.AreEqual("p = FFITarget.C.B.DupTargetTest.DupTargetTest();\n", newNodes.ElementAt(0).ToString()); // Assert that element resolver does not hold namespace mapping for hidden class. KeyValuePair <string, string> resolvedName; Assert.IsFalse(elementResolver.ResolutionMap.TryGetValue("FFITarget.C.B.DupTargetTest", out resolvedName)); }
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 void LookupResolvedName_ForNestedExpressionFromCompiler_RewriteAst() { const string code = @"import (""FFITarget.dll"");"; var mirror = thisTest.RunScriptSource(code); var testCore = thisTest.GetTestCore(); var astNodes = CoreUtils.BuildASTList(testCore, "d = ElementResolverTarget.Create().Property.Method(ElementResolverTarget.Create().Property);"); var elementResolver = new ElementResolver(); var newNodes = ElementRewriter.RewriteElementNames(testCore.ClassTable, elementResolver, astNodes); Assert.AreEqual("d = FFITarget.ElementResolverTarget.Create().Property.Method(FFITarget.ElementResolverTarget.Create().Property);\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); }
private static bool CompileCodeBlockAST(Core core, ParseParam parseParams, IDictionary <string, string> priorNames) { var unboundIdentifiers = new Dictionary <int, List <VariableLine> >(); ProtoCore.BuildStatus buildStatus = null; try { int blockId = ProtoCore.DSASM.Constants.kInvalidIndex; bool parsingPreloadFlag = core.IsParsingPreloadedAssembly; bool parsingCbnFlag = core.IsParsingPreloadedAssembly; core.IsParsingPreloadedAssembly = false; core.IsParsingCodeBlockNode = true; core.ResetForPrecompilation(); var astNodes = parseParams.ParsedNodes; // Lookup namespace resolution map in elementResolver to rewrite // partial classnames with their fully qualified names in ASTs // before passing them for pre-compilation. If partial class is not found in map, // update Resolution map in elementResolver with fully resolved name from compiler. var reWrittenNodes = ElementRewriter.RewriteElementNames(core.ClassTable, parseParams.ElementResolver, astNodes, core.BuildStatus.LogSymbolConflictWarning); if (priorNames != null) { // Use migration rewriter to migrate old method names to new names based on priorNameHints from LibraryServices reWrittenNodes = MigrationRewriter.MigrateMethodNames(reWrittenNodes, priorNames, core.BuildStatus.LogDeprecatedMethodWarning); } // Clone a disposable copy of AST nodes for PreCompile() as Codegen mutates AST's // while performing SSA transforms and we want to keep the original AST's var codeblock = new CodeBlockNode(); var nodes = reWrittenNodes.OfType <AssociativeNode>().Select(NodeUtils.Clone).ToList(); codeblock.Body.AddRange(nodes); buildStatus = PreCompile(string.Empty, core, codeblock, out blockId); core.IsParsingCodeBlockNode = parsingCbnFlag; core.IsParsingPreloadedAssembly = parsingPreloadFlag; parseParams.AppendErrors(buildStatus.Errors); parseParams.AppendWarnings(buildStatus.Warnings); if (buildStatus.ErrorCount > 0) { return(false); } IEnumerable <BuildData.WarningEntry> warnings = buildStatus.Warnings; // Get the unboundIdentifiers from the warnings GetInputLines(parseParams.ParsedNodes, warnings, unboundIdentifiers); foreach (KeyValuePair <int, List <VariableLine> > kvp in unboundIdentifiers) { foreach (VariableLine vl in kvp.Value) { parseParams.AppendUnboundIdentifier(vl.displayName, vl.variable); } } return(true); } catch (Exception) { buildStatus = null; return(false); } }
private void ImportProcedure(string library, ProcedureNode proc) { string procName = proc.Name; if (proc.IsAutoGeneratedThisProc || // There could be DS functions that have private access // that shouldn't be imported into the Library proc.AccessModifier == AccessModifier.Private || CoreUtils.IsSetter(procName) || CoreUtils.IsDisposeMethod(procName) || CoreUtils.StartsWithDoubleUnderscores(procName)) { return; } string obsoleteMessage = ""; int classScope = proc.ClassID; string className = string.Empty; MethodAttributes methodAttribute = proc.MethodAttribute; ClassAttributes classAttribute = null; if (classScope != Constants.kGlobalScope) { var classNode = LibraryManagementCore.ClassTable.ClassNodes[classScope]; classAttribute = classNode.ClassAttributes; className = classNode.Name; } // MethodAttribute's HiddenInLibrary has higher priority than // ClassAttribute's HiddenInLibrary var isVisible = true; var canUpdatePeriodically = false; if (methodAttribute != null) { isVisible = !methodAttribute.HiddenInLibrary; canUpdatePeriodically = methodAttribute.CanUpdatePeriodically; } else { if (classAttribute != null) { isVisible = !classAttribute.HiddenInLibrary; } } FunctionType type; if (classScope == Constants.kGlobalScope) { type = FunctionType.GenericFunction; } else { if (CoreUtils.IsGetter(procName)) { type = proc.IsStatic ? FunctionType.StaticProperty : FunctionType.InstanceProperty; string property; if (CoreUtils.TryGetPropertyName(procName, out property)) { procName = property; } } else { if (proc.IsConstructor) { type = FunctionType.Constructor; } else if (proc.IsStatic) { type = FunctionType.StaticMethod; } else { type = FunctionType.InstanceMethod; } } } List <TypedParameter> arguments = proc.ArgumentInfos.Zip( proc.ArgumentTypes, (arg, argType) => { AssociativeNode defaultArgumentNode; // Default argument specified by DefaultArgumentAttribute // takes higher priority if (!TryGetDefaultArgumentFromAttribute(arg, out defaultArgumentNode) && arg.IsDefault) { var binaryExpr = arg.DefaultExpression as BinaryExpressionNode; if (binaryExpr != null) { defaultArgumentNode = binaryExpr.RightNode; } } string shortName = null; if (defaultArgumentNode != null) { shortName = defaultArgumentNode.ToString(); var rewriter = new ElementRewriter(LibraryManagementCore.ClassTable, LibraryManagementCore.BuildStatus.LogSymbolConflictWarning); defaultArgumentNode = defaultArgumentNode.Accept(rewriter); } return(new TypedParameter(arg.Name, argType, defaultArgumentNode, shortName)); }).ToList(); bool isLacingDisabled = false; IEnumerable <string> returnKeys = null; if (proc.MethodAttribute != null) { if (proc.MethodAttribute.ReturnKeys != null) { returnKeys = proc.MethodAttribute.ReturnKeys; } if (proc.MethodAttribute.IsObsolete) { obsoleteMessage = proc.MethodAttribute.ObsoleteMessage; } isLacingDisabled = proc.MethodAttribute.IsLacingDisabled; } var function = new FunctionDescriptor(new FunctionDescriptorParams { Assembly = library, ClassName = className, FunctionName = procName, Parameters = arguments, ReturnType = proc.ReturnType, FunctionType = type, IsVisibleInLibrary = isVisible, ReturnKeys = returnKeys, PathManager = pathManager, IsVarArg = proc.IsVarArg, ObsoleteMsg = obsoleteMessage, CanUpdatePeriodically = canUpdatePeriodically, IsBuiltIn = pathManager.PreloadedLibraries.Contains(library), IsPackageMember = packagedLibraries.Contains(library), IsLacingDisabled = isLacingDisabled }); AddImportedFunctions(library, new[] { function }); }