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