/// <summary>
/// Evaluates a resolved entry that is not a Thunk
/// </summary>
internal bool TryResolveFunction(Context context, FilePosition filePosition, FullSymbol nameForDebuggingPurposes, out FunctionLikeExpression lambda, out FileModuleLiteral file)
{
if (TryResolveEntryByLocation(context, filePosition, nameForDebuggingPurposes, out var resolvedEntry, out file))
{
lambda = resolvedEntry.Function;
return(true);
}
lambda = null;
return(false);
}
/// <nodoc/>
public ResolvedEntry(FullSymbol thunkContextName, Thunk thunk, QualifierSpaceId qualifierSpaceId, bool isVariableDeclaration)
: this()
{
Contract.Requires(thunk != null);
Thunk = thunk;
Location = thunk.Expression.Location;
m_thunkContextNameOrSymbolName = thunkContextName;
IsVariableDeclaration = isVariableDeclaration;
QualifierSpaceId = qualifierSpaceId;
}
public void RelocateForm2()
{
var idt = new SymbolTable();
FullSymbol d2 = FullSymbol.Create(idt, @"c.a.x");
FullSymbol f1 = FullSymbol.Create(idt, @"C.a.b.c.d.cpp");
XAssert.IsFalse(f1.IsWithin(idt, d2));
FullSymbol f2 = f1.Relocate(idt, d2);
XAssert.AreEqual(@"c.a.x.cpp", f2.ToString(idt));
}
/// <nodoc/>
public LocationBasedSymbolReference(FilePosition filePosition, SymbolAtom symbolName, LineInfo location, SymbolTable symbolTable)
: base(location)
{
Contract.Requires(filePosition.IsValid);
Contract.Requires(symbolName.IsValid);
FilePosition = filePosition;
Name = symbolName;
m_fullSymbol = FullSymbol.Create(symbolTable, symbolName);
}
/// <summary>
/// Constructs module literal for namespace.
/// </summary>
protected static TypeOrNamespaceModuleLiteral CreateTypeOrNamespaceModule(FullSymbol namespaceName, ModuleLiteral outerScope, LineInfo location)
{
Contract.Requires(namespaceName.IsValid);
Contract.Requires(outerScope != null);
Contract.Requires(outerScope.IsFileOrGlobal);
ModuleLiteralId moduleId = outerScope.Id.WithName(namespaceName);
return(new TypeOrNamespaceModuleLiteral(moduleId, qualifier: QualifierValue.Unqualified,
outerScope: outerScope, location: location));
}
/// <summary>
/// Constructs a new Value pip
/// </summary>
public ValuePip(
FullSymbol symbol,
QualifierId qualifier,
LocationData locationData)
{
Contract.Requires(symbol.IsValid);
Contract.Requires(locationData.IsValid);
Symbol = symbol;
Qualifier = qualifier;
LocationData = locationData;
}
public void GetParent()
{
var idt = new SymbolTable();
FullSymbol da = FullSymbol.Create(idt, @"c.a");
FullSymbol parent = da.GetParent(idt);
XAssert.AreEqual(@"c", parent.ToString(idt));
da = FullSymbol.Create(idt, @"c.a.b");
parent = da.GetParent(idt);
XAssert.AreEqual(@"c.a", parent.ToString(idt));
}
internal TValue this[FullSymbol key]
{
get
{
return(m_fullSymbolsToValues[key]);
}
set
{
m_fullSymbolsToValues[key] = value;
}
}
public void IsInitialized()
{
FullSymbol p = default(FullSymbol);
XAssert.IsFalse(p.IsValid);
var idt = new SymbolTable();
p = FullSymbol.Create(idt, @"C.AAA.CCC");
XAssert.AreEqual(@"C.AAA.CCC", p.ToString(idt));
XAssert.IsTrue(p.IsValid);
}
/// <summary>
/// Gets module or namespace based on module id.
/// </summary>
public EvaluationResult GetNamespace(ImmutableContextBase context, FullSymbol fullName, bool recurs, ModuleLiteral origin, LineInfo location)
{
ModuleBinding binding = GetNamespaceBinding(context, fullName, recurs);
if (binding == null)
{
context.Errors.ReportMissingNamespace(origin ?? this, fullName, this, location);
return(EvaluationResult.Error);
}
return(EvaluationResult.Create(binding.Body));
}
/// <summary>
/// Converts a string to a FullSymbol
/// </summary>
/// <param name="symbolTable">SymbolTable to use to convert the string</param>
/// <param name="str">String to convert to FullSymbol</param>
/// <returns>The result of converting the provided string to a FullSymbol</returns>
public static FullSymbol StringToFullSymbol(this SymbolTable symbolTable, string str)
{
FullSymbol fullSymbol;
if (FullSymbol.TryGet(symbolTable, str, out fullSymbol))
{
return(fullSymbol);
}
else
{
throw new ArgumentException("Unable to find FullSymbol for string: '" + str + "'");
}
}
/// <summary>
/// Deserializes
/// </summary>
public static ValuePathFileAccessAllowlistEntry Deserialize(BuildXLReader reader)
{
Contract.Requires(reader != null);
var state = ReadState(reader);
FullSymbol symbol = reader.ReadFullSymbol();
return(new ValuePathFileAccessAllowlistEntry(
symbol,
state.PathRegex,
state.AllowsCaching,
state.Name));
}
/// <nodoc />
protected void RegisterNamespaceDefinition(
GlobalModuleLiteral globalModuleLiteral,
AmbientNamespaceDefinition namespaceDefinition)
{
Contract.Requires(globalModuleLiteral != null);
globalModuleLiteral.AddNamespace(
FullSymbol.Create(globalModuleLiteral.SymbolTable, namespaceDefinition.Name),
default(UniversalLocation),
null,
out TypeOrNamespaceModuleLiteral registeredModule);
RegisterFunctionDefinitions(registeredModule, namespaceDefinition.FunctionDefinitions);
}
public bool Contains(KeyValuePair <string, TValue> item)
{
FullSymbol keyFullSymbol = m_symbolTable.StringToFullSymbol(item.Key);
if (ContainsKey(keyFullSymbol))
{
if (this[keyFullSymbol].Equals(item.Value))
{
return(true);
}
}
return(false);
}
private void AddAllowListEntry(IFileAccessAllowlistEntry allowlistEntry, bool allowsCaching)
{
SerializableRegex pathRegex;
string regexError;
if (string.IsNullOrEmpty(allowlistEntry.PathRegex))
{
if (!TryCreateAllowlistRegex(Regex.Escape(allowlistEntry.PathFragment), out pathRegex, out regexError))
{
throw new BuildXLException("An allowlist regex should never fail to construct from an escaped pattern: " + regexError);
}
}
else
{
if (!TryCreateAllowlistRegex(allowlistEntry.PathRegex, out pathRegex, out regexError))
{
throw new BuildXLException("A regex should have already been validated when parsed: " + regexError);
}
}
if (!string.IsNullOrEmpty(allowlistEntry.Value))
{
Add(
new ValuePathFileAccessAllowlistEntry(
outputValue: FullSymbol.Create(m_context.SymbolTable, allowlistEntry.Value),
pathRegex: pathRegex,
allowsCaching: allowsCaching,
name: allowlistEntry.Name));
}
else
{
object toolPath = allowlistEntry.ToolPath.GetValue();
var executablePath =
toolPath switch
{
FileArtifact file => new DiscriminatingUnion <AbsolutePath, PathAtom>(file.Path),
PathAtom toolName => new DiscriminatingUnion <AbsolutePath, PathAtom>(toolName),
_ => null,
};
Contract.RequiresNotNull(executablePath);
Add(
new ExecutablePathAllowlistEntry(
executable: executablePath,
pathRegex: pathRegex,
allowsCaching: allowsCaching,
name: allowlistEntry.Name));
}
}
/// <summary>
/// Creates a ValueDependency
/// </summary>
public ValueDependency(
FullSymbol parentIdentifier,
QualifierId parentQualifier,
LocationData parentLocation,
FullSymbol childIdentifier,
QualifierId childQualifier,
LocationData childLocation)
{
ParentIdentifier = parentIdentifier;
ParentQualifier = parentQualifier;
ChildIdentifier = childIdentifier;
ChildQualifier = childQualifier;
ParentLocation = parentLocation;
ChildLocation = childLocation;
}
/// <summary>
/// Evaluates a member using by resolving a symbol by a full name.
/// </summary>
/// <remarks>
/// DScript V2 feature.
/// </remarks>
internal EvaluationResult EvaluateEntryByFullName(Context context, FullSymbol fullName, LineInfo location)
{
ResolvedEntry resolvedEntry = default(ResolvedEntry);
if (CurrentFileModule?.TryGetResolvedEntryByFullName(fullName, out resolvedEntry) == true)
{
return(EvaluateResolvedSymbol(context, this, location, resolvedEntry));
}
// This is an assertion but not a graceful error, because resolution may fail only if something went wrong.
string message = I($"Can't find resolved symbol by a full name '{fullName.ToString(context.FrontEndContext.SymbolTable)}'");
Contract.Assert(false, message);
return(EvaluationResult.Undefined);
}
public void IsValidIdChar()
{
XAssert.IsTrue(FullSymbol.IsValidAbsoluteIdChar('a'));
XAssert.IsTrue(FullSymbol.IsValidAbsoluteIdChar('z'));
XAssert.IsTrue(FullSymbol.IsValidAbsoluteIdChar('A'));
XAssert.IsTrue(FullSymbol.IsValidAbsoluteIdChar('Z'));
XAssert.IsTrue(FullSymbol.IsValidAbsoluteIdChar('0'));
XAssert.IsTrue(FullSymbol.IsValidAbsoluteIdChar('9'));
XAssert.IsFalse(FullSymbol.IsValidAbsoluteIdChar('\\'));
XAssert.IsFalse(FullSymbol.IsValidAbsoluteIdChar('/'));
XAssert.IsFalse(FullSymbol.IsValidAbsoluteIdChar(':'));
XAssert.IsFalse(FullSymbol.IsValidAbsoluteIdChar('.'));
XAssert.IsFalse(FullSymbol.IsValidAbsoluteIdChar('?'));
}
/// <inheritdoc />
public override FullSymbol ReadFullSymbol()
{
var alternateSymbolSeparator = ReadChar();
if (alternateSymbolSeparator == default)
{
return(FullSymbol.Create(m_pipExecutionContext.SymbolTable, ReadString()));
}
else
{
OptimizedSymbols++;
var segments = ReadArray(r => r.ReadStringId());
var id = m_pipExecutionContext.SymbolTable.AddComponents(HierarchicalNameId.Invalid, segments);
return(new FullSymbol(id, alternateSymbolSeparator));
}
}
/// <nodoc />
public void ReportMissingNamespace(ModuleLiteral env, FullSymbol name, ModuleLiteral relatedEnv, LineInfo lineInfo)
{
Contract.Requires(env != null);
Contract.Requires(name.IsValid);
Contract.Requires(relatedEnv != null);
var relatedLocation = relatedEnv.Location.AsLoggingLocation(relatedEnv, Context).ToDisplayString();
var relatedMessage = env == relatedEnv ? string.Empty : I($", related location '{relatedLocation}'");
var location = lineInfo.AsUniversalLocation(env, Context);
Logger.ReportMissingNamespace(
LoggingContext,
location.AsLoggingLocation(),
name.ToDisplayString(Context),
relatedMessage,
Context.GetStackTraceAsErrorMessage(location));
}
private CompositeGraphFingerprint CreateRandomWithModulesAndValues(string[] modules, string[] valueNames)
{
return(new CompositeGraphFingerprint()
{
OverallFingerprint = new ContentFingerprint(Fingerprint.Random(33)),
FilterHash = Fingerprint.Random(33),
EvaluationFilter = new EvaluationFilter(
m_symbolTable,
m_pathTable,
valueNames.Select(vn => FullSymbol.Create(this.m_symbolTable, new StringSegment(vn))).ToArray(),
new AbsolutePath[0],
modules.Select(m => StringId.Create(this.m_pathTable.StringTable, m)).ToArray()),
BuildEngineHash = FingerprintUtilities.ZeroFingerprint,
ConfigFileHash = FingerprintUtilities.ZeroFingerprint,
QualifierHash = FingerprintUtilities.ZeroFingerprint,
});
}
/// <nodoc />
public TopLevelValueInfo(
Thunk activeThunk,
FullSymbol valueName,
AbsolutePath specFile,
LineInfo valueDeclarationLineInfo,
object templateValue)
{
Contract.Requires(activeThunk != null);
Contract.Requires(valueName.IsValid);
Contract.Requires(specFile.IsValid);
ActiveThunk = activeThunk;
ValueName = valueName;
SpecFile = specFile;
ValueDeclarationLineInfo = valueDeclarationLineInfo;
CapturedTemplateValue = templateValue;
}
/// <summary>
/// Class constructor.
/// </summary>
public PipProvenance(
long semiStableHash,
ModuleId moduleId,
StringId moduleName,
FullSymbol outputValueSymbol,
LocationData token,
QualifierId qualifierId,
PipData usage)
{
SemiStableHash = semiStableHash;
ModuleId = moduleId;
ModuleName = moduleName;
OutputValueSymbol = outputValueSymbol;
Token = token;
QualifierId = qualifierId;
Usage = usage;
}
/// <summary>
/// Adds a callback for a particular symbol that will be called
/// at evaluation time when that symbol is evaluated.
/// </summary>
/// <remarks>
/// Useful for programmatically executing customized evaluation for non-DScript
/// resolvers
/// </remarks>
public static void AddEvaluationCallbackToFileModule(
FileModuleLiteral fileModule,
Func <Context, ModuleLiteral, EvaluationStackFrame, Task <EvaluationResult> > evaluationCallback,
FullSymbol symbol,
int position)
{
var sourceFilePath = fileModule.Path;
var outputResolvedEntry = new ResolvedEntry(
symbol,
(Context context, ModuleLiteral env, EvaluationStackFrame args) => evaluationCallback(context, env, args),
// The following position is a contract right now with he generated ast in the workspace resolver
// we have to find a nicer way to handle and register these.
TypeScript.Net.Utilities.LineInfo.FromLineAndPosition(0, position)
);
fileModule.AddResolvedEntry(symbol, outputResolvedEntry);
fileModule.AddResolvedEntry(new FilePosition(position, sourceFilePath), outputResolvedEntry);
}
/// <summary>
/// Creates a mutable named child context.
/// </summary>
/// <remarks>
/// Until all mutable child contexts have been disposed, no mutations are allowed on the current context.
/// </remarks>
public Context CreateWithName(Thunk activeThunk, FullSymbol name, ModuleLiteral module, object templateValue, LineInfo location)
{
Contract.Requires(name.IsValid);
Contract.Requires(module != null);
var topLevelValueState = new TopLevelValueInfo(
activeThunk,
name,
module.Path,
location,
templateValue);
return(new Context(
ContextTree,
this,
module,
topLevelValueState,
FileType,
EvaluatorConfiguration,
EvaluationScheduler));
}
internal static PipProvenance Deserialize(PipReader reader)
{
Contract.Requires(reader != null);
long semiStableHash = reader.ReadInt64();
ModuleId moduleId = reader.ReadModuleId();
StringId moduleName = reader.ReadStringId();
FullSymbol outputValueName = reader.ReadFullSymbol();
LocationData token = reader.ReadLocationData();
QualifierId qualifierId = new QualifierId(reader.ReadInt32Compact());
PipData usage = reader.ReadPipData();
return(new PipProvenance(
semiStableHash,
moduleId,
moduleName,
outputValueName,
token,
qualifierId,
usage));
}
/// <summary>
/// Helper method with defaults for convenient creation from unit tests
/// </summary>
public static PipConstructionHelper CreateForTesting(
PipExecutionContext context,
AbsolutePath?objectRoot = null,
AbsolutePath?tempRoot = null,
string moduleName = null,
string specRelativePath = null,
string symbol = null,
AbsolutePath?specPath = null,
QualifierId?qualifierId = null)
{
return(Create(
context,
objectRoot ?? AbsolutePath.Create(context.PathTable, "d:\\test\\obj"),
tempRoot ?? objectRoot ?? AbsolutePath.Create(context.PathTable, "d:\\test\\tmp"),
new ModuleId(1),
moduleName ?? "TestModule",
RelativePath.Create(context.StringTable, specRelativePath ?? "spec"),
FullSymbol.Create(context.SymbolTable, symbol ?? "testValue"),
new LocationData(specPath ?? AbsolutePath.Create(context.PathTable, "d:\\src\\spec.dsc"), 0, 0),
qualifierId ?? QualifierId.Unqualified));
}
public void Combine()
{
var idt = new SymbolTable();
FullSymbol a1 = FullSymbol.Create(idt, @"C");
SymbolAtom p1 = SymbolAtom.Create(idt.StringTable, "A");
FullSymbol a2 = a1.Combine(idt, p1);
XAssert.AreEqual(@"C.A", a2.ToString(idt));
a1 = FullSymbol.Create(idt, @"C.X");
p1 = SymbolAtom.Create(idt.StringTable, "A");
a2 = a1.Combine(idt, p1);
XAssert.AreEqual(@"C.X.A", a2.ToString(idt));
a1 = FullSymbol.Create(idt, @"C.X");
p1 = SymbolAtom.Create(idt.StringTable, "A");
SymbolAtom p2 = SymbolAtom.Create(idt.StringTable, "B");
a2 = a1.Combine(idt, p1, p2);
XAssert.AreEqual(@"C.X.A.B", a2.ToString(idt));
a1 = FullSymbol.Create(idt, @"C.X");
p1 = SymbolAtom.Create(idt.StringTable, "A");
p2 = SymbolAtom.Create(idt.StringTable, "B");
SymbolAtom p3 = SymbolAtom.Create(idt.StringTable, "C");
a2 = a1.Combine(idt, p1, p2, p3);
XAssert.AreEqual(@"C.X.A.B.C", a2.ToString(idt));
a1 = FullSymbol.Create(idt, @"C");
PartialSymbol rp = PartialSymbol.Create(idt.StringTable, @"A.B");
a2 = a1.Combine(idt, rp);
XAssert.AreEqual(@"C.A.B", a2.ToString(idt));
a1 = FullSymbol.Create(idt, @"C.X");
rp = PartialSymbol.Create(idt.StringTable, @"A.B");
a2 = a1.Combine(idt, rp);
XAssert.AreEqual(@"C.X.A.B", a2.ToString(idt));
}
private void AddWhiteListEntry(IFileAccessWhitelistEntry whitelistEntry, bool allowsCaching)
{
SerializableRegex pathRegex;
string regexError;
if (string.IsNullOrEmpty(whitelistEntry.PathRegex))
{
if (!TryCreateWhitelistRegex(Regex.Escape(whitelistEntry.PathFragment), out pathRegex, out regexError))
{
throw new BuildXLException("A whitelist regex should never fail to construct from an escaped pattern: " + regexError);
}
}
else
{
if (!TryCreateWhitelistRegex(whitelistEntry.PathRegex, out pathRegex, out regexError))
{
throw new BuildXLException("A regex should have already been validated when parsed: " + regexError);
}
}
if (!string.IsNullOrEmpty(whitelistEntry.Value))
{
Add(
new ValuePathFileAccessWhitelistEntry(
outputValue: FullSymbol.Create(m_context.SymbolTable, whitelistEntry.Value),
pathRegex: pathRegex,
allowsCaching: allowsCaching,
name: whitelistEntry.Name));
}
else
{
Add(
new ExecutablePathWhitelistEntry(
executablePath: whitelistEntry.ToolPath,
pathRegex: pathRegex,
allowsCaching: allowsCaching,
name: whitelistEntry.Name));
}
}
public AstConversionContext(
RuntimeModelContext runtimeModelContext,
AbsolutePath currentSpecPath,
ISourceFile currentSourceFile,
FileModuleLiteral currentFileModule)
{
RuntimeModelContext = runtimeModelContext;
CurrentSpecPath = currentSpecPath;
CurrentSourceFile = currentSourceFile;
CurrentFileModule = currentFileModule;
QualifierDeclarationKeyword = CreateSymbol(Constants.Names.CurrentQualifier);
WithQualifierKeyword = CreateSymbol(Constants.Names.WithQualifierFunction);
UndefinedLiteral = CreateSymbol(Constants.Names.Undefined);
LegacyPackageKeyword = CreateSymbol(Constants.Names.LegacyModuleConfigurationFunctionCall);
ModuleKeyword = CreateSymbol(Constants.Names.ModuleConfigurationFunctionCall);
TemplateReference = CreateSymbol(Constants.Names.TemplateReference);
RuntimeRootNamespaceSymbol = CreateSymbol(Constants.Names.RuntimeRootNamespaceAlias);
UnsafeNamespace = CreateFullSymbol(Constants.Names.UnsafeNamespace);
UnsafeOutputFile = CreateSymbol(Constants.Names.UnsafeOutputFile);
UnsafeExOutputDirectory = CreateSymbol(Constants.Names.UnsafeExOutputDirectory);
}
