private bool TryGetDsInfo(CallNode callNode, TexlBinding binding, out IExternalDataSource dsInfo)
{
Contracts.AssertValueOrNull(callNode);
Contracts.AssertValue(binding);
dsInfo = null;
if (callNode == null || !binding.IsDelegatable(callNode) || !binding.GetType(callNode).IsTable)
{
return(false);
}
var callInfo = binding.GetInfo(callNode);
if (callInfo == null)
{
return(false);
}
var function = callInfo.Function;
if (function == null)
{
return(false);
}
bool success = function.TryGetDataSource(callNode, binding, out var external);
dsInfo = (IExternalDataSource)external;
return(success);
}
public override bool TryGetDelegationMetadata(CallNode node, TexlBinding binding, out IDelegationMetadata metadata)
{
Contracts.AssertValue(node);
Contracts.AssertValue(binding);
metadata = null;
// Get metadata if it's an entity.
IExpandInfo entityInfo;
if (binding.TryGetEntityInfo(node.Args.Children[0], out entityInfo))
{
Contracts.AssertValue(entityInfo.ParentDataSource);
Contracts.AssertValue(entityInfo.ParentDataSource.DataEntityMetadataProvider);
var metadataProvider = entityInfo.ParentDataSource.DataEntityMetadataProvider;
IDataEntityMetadata entityMetadata;
if (!metadataProvider.TryGetEntityMetadata(entityInfo.Identity, out entityMetadata))
{
return(false);
}
metadata = entityMetadata.DelegationMetadata.VerifyValue();
return(true);
}
if (!TryGetValidDataSourceForDelegation(node, binding, FunctionDelegationCapability, out var ds))
{
return(false);
}
metadata = ds.DelegationMetadata;
return(true);
}
private CallNode convertMember(CallNode parent, ParseNode m)
{
if (!m.Equals("<member>"))
{
return(null);
}
bool hasFunctionCall = m.Contains("<function_call>"),
hasMember = m.Contains("<member>");
CallNode output;
if (hasFunctionCall)
{
output = createObjectFunctionCall(parent, m["<symbol>"], m["<function_call>"]);
}
else
{
output = createSymbolNode(parent, m["<symbol>"]);
}
if (hasMember)
{
output = convertMember(output, m["<member>"]);
}
return(output);
}
public override bool UpdateDataQuerySelects(CallNode callNode, TexlBinding binding, DataSourceToQueryOptionsMap dataSourceToQueryOptionsMap)
{
Contracts.AssertValue(callNode);
Contracts.AssertValue(binding);
if (!CheckArgsCount(callNode, binding))
{
return(false);
}
TexlNode[] args = callNode.Args.Children.VerifyValue();
DType dsType = binding.GetType(args[0]);
if (dsType.AssociatedDataSources == null)
{
return(false);
}
var resultType = binding.GetType(callNode).VerifyValue();
bool retval = false;
foreach (var typedName in resultType.GetNames(DPath.Root))
{
DType columnType = typedName.Type;
string columnName = typedName.Name.Value;
Contracts.Assert(dsType.Contains(new DName(columnName)));
retval |= dsType.AssociateDataSourcesToSelect(dataSourceToQueryOptionsMap, columnName, columnType, true);
}
return(retval);
}
public bool IsValidCallNode(CallNode node, TexlBinding binding, OperationCapabilityMetadata metadata)
{
Contracts.AssertValue(node);
Contracts.AssertValue(binding);
Contracts.AssertValue(metadata);
if (!IsValidNode(node, binding))
{
SuggestDelegationHint(node, binding);
return(false);
}
// If the node is not row scoped and it's valid then it can be delegated.
var isRowScoped = binding.IsRowScope(node);
if (!isRowScoped)
{
return(true);
}
CallInfo callInfo = binding.GetInfo(node);
if (callInfo?.Function != null && ((TexlFunction)callInfo.Function).IsRowScopedServerDelegatable(node, binding, metadata))
{
return(true);
}
var telemetryMessage = string.Format("Kind:{0}, isRowScoped:{1}", node.Kind, isRowScoped);
SuggestDelegationHintAndAddTelemetryMessage(node, binding, telemetryMessage);
TrackingProvider.Instance.SetDelegationTrackerStatus(DelegationStatus.UndelegatableFunction, node, binding, _function, DelegationTelemetryInfo.CreateUndelegatableFunctionTelemetryInfo((TexlFunction)callInfo?.Function));
return(false);
}
private bool TryGetEntityInfo(CallNode callNode, TexlBinding binding, out IExpandInfo entityInfo)
{
Contracts.AssertValueOrNull(callNode);
Contracts.AssertValue(binding);
entityInfo = null;
if (callNode == null || !binding.GetType(callNode).IsTable)
{
return(false);
}
var callInfo = binding.GetInfo(callNode);
if (callInfo == null)
{
return(false);
}
var function = callInfo.Function;
if (function == null)
{
return(false);
}
return(function.TryGetEntityInfo(callNode, binding, out entityInfo));
}
private void InitImpl(CallNode node, VariableMap map)
{
Init(node, map);
_willAlloc.CopyFrom(node.UsedArgs);
_willSpill.Reset();
}
private static IAnalysisSet FsBasename(FunctionValue func, Node node, AnalysisUnit unit, IAnalysisSet @this, IAnalysisSet[] args)
{
CallNode call = (CallNode)node;
IAnalysisSet res = AnalysisSet.Empty;
if (args.Length == 2)
{
foreach (var extArg in args[1])
{
var strExt = extArg.Value.GetStringValue();
if (strExt != null)
{
foreach (var nameArg in args[0])
{
string name = nameArg.Value.GetStringValue();
if (name != null)
{
string oldName = name;
if (name.EndsWith(strExt, StringComparison.OrdinalIgnoreCase))
{
name = name.Substring(0, name.Length - strExt.Length);
}
res = res.Union(unit.Analyzer.GetConstant(name).Proxy);
}
}
}
}
}
if (res.Count == 0)
{
return(unit.Analyzer._emptyStringValue.SelfSet);
}
return(res);
}
private static IAnalysisSet FsReadDirSync(FunctionValue func, Node node, AnalysisUnit unit, IAnalysisSet @this, IAnalysisSet[] args)
{
CallNode call = (CallNode)node;
if (call.Arguments.Length == 1)
{
var ee = new ExpressionEvaluator(unit);
IAnalysisSet arraySet;
ReadDirSyncArrayValue array;
if (!unit.GetDeclaringModuleEnvironment().TryGetNodeValue(NodeEnvironmentKind.ArrayValue, call, out arraySet))
{
array = new ReadDirSyncArrayValue(
unit.ProjectEntry,
node
);
arraySet = array.SelfSet;
unit.GetDeclaringModuleEnvironment().AddNodeValue(NodeEnvironmentKind.ArrayValue, call, arraySet);
}
else
{
array = (ReadDirSyncArrayValue)arraySet.First().Value;
}
foreach (var path in ee.MergeStringLiterals(call.Arguments[0]))
{
array.AddDirectoryMembers(unit, path);
}
return(array.SelfSet);
}
return(AnalysisSet.Empty);
}
static MethodDeclarationNode GenerateDestructor(ClassDeclarationNode classDeclarationNode) //Generates destruction method from variable list in class
{
foreach (MethodDeclarationNode method in classDeclarationNode.MethodDeclarations) //check if method already given
{
if (method.isDestruction)
{
return(method);
}
}
MethodDeclarationNode destructor = new MethodDeclarationNode(true);
foreach (VariableDeclarationNode declaration in classDeclarationNode.VariableDeclarations) //for every variable collect a destruction function
{
CallNode call = new CallNode();
call.SetCallerName(declaration.name);
string className = declaration.expression.call.CalleeNames[0];
foreach (ClassDeclarationNode classDeclaration in _rootNode.ClassDeclarations)
{
if (classDeclaration.name == className)
{
call.AddCallee(GenerateDestructor(classDeclaration).name, new List <ExpressionNode>());
}
}
destructor.AddBodyNode(call); //Add destruction call to method
}
return(destructor);
}
public virtual void Visit(CallNode node)
{
if (node != null)
{
AcceptChildren(node);
}
}
public override string Visit(CallNode node)
{
var expr = Visit(node.Expr);
var parameters = string.Join(", ", node.Parameters.Select(Visit));
return($"{expr}({parameters})");
}
public override bool IsServerDelegatable(CallNode callNode, TexlBinding binding)
{
Contracts.AssertValue(callNode);
Contracts.AssertValue(binding);
IExternalDataSource dataSource = null;
// Only delegate First, not last
if (!_isFirst)
{
return(false);
}
// If has top capability (e.g. Dataverse)
if (TryGetValidDataSourceForDelegation(callNode, binding, FunctionDelegationCapability, out dataSource))
{
return(true);
}
// If is a client-side pageable data source
if (TryGetDataSource(callNode, binding, out dataSource) && dataSource.Kind == DataSourceKind.Connected && dataSource.IsPageable)
{
return(true);
}
if (dataSource != null && dataSource.IsDelegatable)
{
binding.ErrorContainer.EnsureError(DocumentErrorSeverity.Warning, callNode, TexlStrings.OpNotSupportedByServiceSuggestionMessage_OpNotSupportedByService, Name);
}
return(false);
}
public override string VisitFunctionCall(CallNode functionCall)
{
var procedureCall = functionCall;
var param = "";
if (procedureCall.Parameters.Any())
{
foreach (var procedureCallParameter in procedureCall.Parameters)
{
param += VisitNode(procedureCallParameter);
param += ",";
}
param = param.Remove(param.Length - 1);
}
//if (procedureCall.Name.ToUpper() == "WRITELN")
//{
// var assembly = "using System;";
// if (_assembliesCalled.Contains(assembly) != true)
// {
// _assembliesCalled.Add(assembly);
// }
// return $"{AddSpaces()}Console.WriteLine({param});\r\n";
//}
return($"{AddSpaces()}{procedureCall.Name}({param})");
}
internal CallNode CreateCall(Operand op, FunctionDeclaration fn)
{
var node = new CallNode(op, fn);
AddNode(node);
return(node);
}
public static bool FindCurFuncAndArgs(TexlNode curNode, int cursorPos, TexlBinding binding, out TexlFunction curFunc, out int argIndex, out int argCount, out DType expectedType)
{
Contracts.AssertValue(curNode);
Contracts.AssertValue(binding);
if (curNode.Kind == NodeKind.Call)
{
CallNode callNode = curNode.CastCall();
if (callNode.Token.Span.Lim <= cursorPos && callNode.ParenClose != null && cursorPos <= callNode.ParenClose.Span.Min)
{
CallInfo info = binding.GetInfo(callNode);
if (info.Function != null)
{
curFunc = info.Function;
argIndex = 0;
argCount = callNode.Args.Count;
expectedType = curFunc.ParamTypes.Length > 0 ? curFunc.ParamTypes[0] : DType.Error;
return(true);
}
}
}
if (IntellisenseHelper.TryGetInnerMostFunction(curNode, binding, out curFunc, out argIndex, out argCount))
{
expectedType = curFunc.ParamTypes.Length > argIndex ? curFunc.ParamTypes[argIndex] : DType.Error;
return(true);
}
expectedType = DType.Error;
return(false);
}
public override bool SupportsPaging(CallNode callNode, TexlBinding binding)
{
IList <FirstNameNode> dsNodes;
if (!TryGetDataSourceNodes(callNode, binding, out dsNodes))
{
return(false);
}
var args = callNode.Args.Children.VerifyValue();
var count = args.Count();
for (int i = 1; i < count;)
{
if (!binding.IsPageable(args[i]))
{
return(false);
}
// If there are an odd number of args, the last arg also participates.
i += 2;
if (i == count)
{
i--;
}
}
return(true);
}
private bool TryGetDsNodes(CallNode callNode, TexlBinding binding, out IList <FirstNameNode> dsInfos)
{
Contracts.AssertValueOrNull(callNode);
Contracts.AssertValue(binding);
dsInfos = new List <FirstNameNode>();
if (callNode == null || !(binding.GetType(callNode).IsAggregate))
{
return(false);
}
var callInfo = binding.GetInfo(callNode);
if (callInfo == null)
{
return(false);
}
var function = callInfo.Function;
if (function == null)
{
return(false);
}
return(function.TryGetDataSourceNodes(callNode, binding, out dsInfos));
}
public CallArgumentNode(CallNode call, VariableData src, VariableData conv)
: base(CodeNodeType.CallArgument)
{
Call = call;
Source = src;
Conv = conv;
}
public void VisitCall(CallNode node)
{
UpdateLine(node);
node.Proc.Accept(this);
node.Arguments.ForEach(a => a.Accept(this));
asm.Call((short)node.Arguments.Count);
}
public override bool UpdateDataQuerySelects(CallNode callNode, TexlBinding binding, DataSourceToQueryOptionsMap dataSourceToQueryOptionsMap)
{
Contracts.AssertValue(callNode);
Contracts.AssertValue(binding);
// Ignore delegation warning
if (!CheckArgsCount(callNode, binding, DocumentErrorSeverity.Moderate))
{
return(false);
}
TexlNode[] args = callNode.Args.Children.VerifyValue();
DType dsType = binding.GetType(args[0]);
if (dsType.AssociatedDataSources == null)
{
return(false);
}
DType columnType = binding.GetType(args[1]);
StrLitNode columnNode = args[1].AsStrLit();
if (columnType.Kind != DKind.String || columnNode == null)
{
return(false);
}
string columnName = columnNode.Value;
Contracts.Assert(dsType.Contains(new DName(columnName)));
return(dsType.AssociateDataSourcesToSelect(dataSourceToQueryOptionsMap, columnName, columnType, true));
}
// Typecheck an input for this function, and get the cursor type for an invocation with that input.
// arg0 and arg0Type correspond to the input and its type.
// The cursor type for aggregate functions is generally the type of a row in the input schema (table),
// for example Table in an invocation Average(Table, valueFunction).
// Returns true on success, false if the input or its type are invalid with respect to this function's declaration
// (and populate the error container accordingly).
public virtual bool CheckInput(TexlNode inputNode, DType inputSchema, IErrorContainer errors, out DType typeScope)
{
Contracts.AssertValue(inputNode);
Contracts.Assert(inputSchema.IsValid);
Contracts.AssertValue(errors);
CallNode callNode = inputNode.Parent.CastList().Parent.CastCall();
Contracts.AssertValue(callNode);
typeScope = inputSchema;
bool fArgsValid = true;
if (_function.ParamTypes.Length == 0)
{
switch (typeScope.Kind)
{
case DKind.Record:
break;
case DKind.Error:
fArgsValid = false;
errors.EnsureError(inputNode, TexlStrings.ErrBadType);
break;
default:
fArgsValid = false;
errors.Error(callNode, TexlStrings.ErrBadType);
break;
}
}
else if (_function.ParamTypes[0].IsTable)
{
if (!typeScope.IsTable)
{
errors.Error(callNode, TexlStrings.ErrNeedTable_Func, _function.Name);
fArgsValid = false;
}
// This assumes that the lambdas operate on the individual records
// of the table, not the entire table.
bool fError = false;
typeScope = typeScope.ToRecord(ref fError);
fArgsValid &= !fError;
}
else
{
Contracts.Assert(_function.ParamTypes[0].IsRecord);
if (!typeScope.IsRecord)
{
errors.Error(callNode, TexlStrings.ErrNeedRecord_Func, _function.Name);
bool fError = false;
typeScope = typeScope.ToRecord(ref fError);
fArgsValid = false;
}
}
return(fArgsValid);
}
public override bool IsRowScopedServerDelegatable(CallNode callNode, TexlBinding binding, OperationCapabilityMetadata metadata)
{
Contracts.AssertValue(callNode);
Contracts.AssertValue(binding);
Contracts.AssertValue(metadata);
return(base.IsRowScopedServerDelegatable(callNode, binding, metadata));
}
public CallInfo(TexlFunction function, CallNode node)
{
Contracts.AssertValue(function);
Contracts.AssertValue(node);
Function = function;
Node = node;
}
public override void PostWalk(CallNode node)
{
base.PostWalk(node);
if (!node.InBrackets)
{
HasSideEffects = true;
}
}
public override bool IsServerDelegatable(CallNode callNode, TexlBinding binding)
{
Contracts.AssertValue(callNode);
Contracts.AssertValue(binding);
if (FunctionDelegationCapability.Capabilities == DelegationCapability.None)
{
return(false);
}
if (!CheckArgsCount(callNode, binding))
{
return(false);
}
IExternalDataSource dataSource;
if (!TryGetValidDataSourceForDelegation(callNode, binding, FunctionDelegationCapability, out dataSource))
{
if (dataSource != null && dataSource.IsDelegatable)
{
binding.ErrorContainer.EnsureError(DocumentErrorSeverity.Warning, callNode, TexlStrings.OpNotSupportedByServiceSuggestionMessage_OpNotSupportedByService, Name);
}
return(false);
}
var args = callNode.Args.Children.VerifyValue();
if (binding.GetType(args[0]).HasExpandInfo ||
(!binding.IsFullRecordRowScopeAccess(args[1]) && args[1].Kind != NodeKind.FirstName) ||
!binding.IsRowScope(args[1]) ||
binding.GetType(args[1]) != DType.Number ||
ExpressionContainsView(callNode, binding))
{
SuggestDelegationHint(callNode, binding);
if (binding.GetType(args[1]) != DType.Number)
{
DelegationTrackerCore.SetDelegationTrackerStatus(DelegationStatus.NotANumberArgType, callNode, binding, this, DelegationTelemetryInfo.CreateEmptyDelegationTelemetryInfo());
}
else
{
DelegationTrackerCore.SetDelegationTrackerStatus(DelegationStatus.InvalidArgType, callNode, binding, this, DelegationTelemetryInfo.CreateEmptyDelegationTelemetryInfo());
}
return(false);
}
if (binding.IsFullRecordRowScopeAccess(args[1]))
{
return(GetDottedNameNodeDelegationStrategy().IsValidDottedNameNode(args[1].AsDottedName(), binding, null, null));
}
var firstNameStrategy = GetFirstNameNodeDelegationStrategy().VerifyValue();
return(firstNameStrategy.IsValidFirstNameNode(args[1].AsFirstName(), binding, null));
}
private SymbolNode createSymbolNode(CallNode parent, ParseNode s)
{
if (!s.Equals("<symbol>"))
{
return(null);
}
return(new SymbolNode(parent.type.VarNames[s.terminals], s.terminals));
}
public override void Visit(CallNode node)
{
base.Visit(node);
if (ShouldInsertModulePathArgument(node))
{
insertionIndex = node.Arguments[0].Context.StartPosition;
}
}
public IEnumerable <ASTNode> Transform(CallNode item)
{
yield return(item);
foreach (var child in TransformAll(item.Contents))
{
yield return(child);
}
}
/// <summary>
/// This method prints the callNode and make an indentation
/// It accepts the ID number of the node and all the parameters of the call node
/// Then outdent
/// </summary>
/// <param name="callNode">The node to print.</param>
/// <returns>Returns null</returns>
public override object Visit(CallNode callNode)
{
Print("CallNode");
Indent++;
callNode.Id.Accept(this);
callNode.Parameters.ForEach(node => node.Accept(this));
Indent--;
return(null);
}
// Gets the inner most function and the current arg index from the current node, if any.
// If there is no inner most function, current arg index will be -1
// and argument count will be -1.
internal static bool TryGetInnerMostFunction(TexlNode nodeCur, TexlBinding bind, out TexlFunction funcCur, out int iarg, out int carg)
{
Contracts.AssertValue(nodeCur);
Contracts.AssertValue(bind);
TexlNode nodeParent = nodeCur.Parent;
TexlNode nodeCallArg = nodeCur;
CallNode callNode = null;
while (nodeParent != null)
{
if (nodeParent.Kind == NodeKind.Call)
{
callNode = nodeParent.AsCall();
break;
}
// The last node before a call's list node is the call arg.
if (nodeParent.Kind != NodeKind.List)
{
nodeCallArg = nodeParent;
}
nodeParent = nodeParent.Parent;
}
if (callNode == null)
{
iarg = -1;
carg = -1;
funcCur = null;
return(false);
}
Contracts.AssertValue(nodeCallArg);
CallInfo info = bind.GetInfo(callNode);
if (info.Function != null)
{
carg = callNode.Args.Count;
for (iarg = 0; iarg < carg; iarg++)
{
if (callNode.Args.Children[iarg] == nodeCallArg)
{
break;
}
}
Contracts.Assert(iarg < carg);
funcCur = (TexlFunction)info.Function;
return(true);
}
iarg = -1;
carg = -1;
funcCur = null;
return(false);
}
public virtual bool Walk(CallNode node) { return true; }
public virtual void PostWalk(CallNode node) { }
public virtual void Visit(CallNode node)
{
if (node != null)
{
if (node.Function != null)
{
node.Function.Accept(this);
}
if (node.Arguments != null)
{
node.Arguments.Accept(this);
}
}
}
