public QualifierValue GetQualifierValue()
{
var qualifierTable = new QualifierTable(m_stringTable);
var qualifierId = qualifierTable.CreateQualifier(new Tuple <string, string>("hey", "hello"));
return(QualifierValue.Create(qualifierId, qualifierTable, m_stringTable));
}
private static List <string> ExtractQualifierSpaceValues(IArrayLiteralExpression valueSpace, DiagnosticContext context, bool emitLogEvents)
{
var values = new List <string>(valueSpace.Elements.Count);
bool hasErrors = false;
foreach (var value in valueSpace.Elements)
{
if (value.Kind != TypeScript.Net.Types.SyntaxKind.StringLiteral)
{
if (emitLogEvents)
{
context.Logger.ReportQualifierSpaceValueMustBeStringLiteral(context.LoggingContext, value.LocationForLogging(context.SourceFile));
}
hasErrors = true;
}
var text = value.Cast <IStringLiteral>().Text;
if (!QualifierTable.IsValidQualifierValue(text))
{
if (emitLogEvents)
{
context.Logger.ReportQualifierSpaceValueMustBeValidValue(context.LoggingContext, value.LocationForLogging(context.SourceFile), text);
}
hasErrors = true;
}
values.Add(text);
}
return(hasErrors ? null : values);
}
/// <nodoc/>
public TableAgnosticWriter(PathTable pathTable, SymbolTable symbolTable, QualifierTable qualifierTable, bool debug, Stream stream, bool leaveOpen, bool logStats)
: base(qualifierTable, debug, stream, leaveOpen, logStats)
{
m_pathTable = pathTable;
m_symbolTable = symbolTable;
m_stringTable = pathTable.StringTable;
}
/// <summary>
/// Creates the empty qualifier value.
/// </summary>
public static QualifierValue CreateEmpty(QualifierTable qualifierTable)
{
Contract.Requires(qualifierTable != null);
// The empty qualifier value is an empty object literal without location nor path. Since this is a runtime object, and not tied to
// a particular declaration in a spec, this is ok
return(new QualifierValue(ObjectLiteral0.SingletonWithoutProvenance, qualifierTable.EmptyQualifierId));
}
public Func <int, QualifierSpaceId> CreateClosure(IResolvedType resolvedType, QualifierTable qualifierTable, ISemanticModel semanticModel)
{
m_resolvedType = resolvedType;
m_qualifierTable = qualifierTable;
m_semanticModel = semanticModel;
return(m_func);
}
/// <nodoc />
public V2QualifiersConverter(QualifierTable qualifierTable, ISemanticModel semanticModel)
{
Contract.Requires(qualifierTable != null);
Contract.Requires(semanticModel != null);
m_qualifierTable = qualifierTable;
m_semanticModel = semanticModel;
}
private static QualifierSpaceId CreateQualifierSpaceId(QualifierTable qualifierTable, QualifierSpaceDeclaration qualifierSpaceDeclaration)
{
if (qualifierSpaceDeclaration.Count == 0)
{
return(qualifierTable.EmptyQualifierSpaceId);
}
return(qualifierTable.CreateQualifierSpace(qualifierSpaceDeclaration));
}
/// <summary>
/// Tries coercing qualifier.
/// </summary>
public bool TryCoerce(
QualifierSpaceId targetQualifierSpaceId,
QualifierTable qualifierTable,
QualifierValueCache cache,
PathTable pathTable,
StringTable stringTable,
LoggingContext loggingContext,
out QualifierValue qualifierValue,
LineInfo location,
bool useDefaultsForCoercion,
AbsolutePath path)
{
Contract.Requires(targetQualifierSpaceId.IsValid);
Contract.Requires(qualifierTable != null);
Contract.Requires(qualifierTable.IsValidQualifierSpaceId(targetQualifierSpaceId));
Contract.Requires(pathTable != null);
Contract.Requires(stringTable != null);
Contract.Requires(loggingContext != null);
#if DEBUG
Contract.Ensures(Contract.ValueAtReturn(out qualifierValue) == null || Contract.Result <bool>() == true, "expected 'qualifierValue' to be set to null when return value is 'false'");
Contract.Ensures(Contract.ValueAtReturn(out qualifierValue) != null || Contract.Result <bool>() == false, "expected 'qualifierValue' to be set to non-null when return value is 'true'");
#endif
qualifierValue = null;
if (targetQualifierSpaceId == qualifierTable.EmptyQualifierSpaceId)
{
qualifierValue = CreateEmpty(qualifierTable);
return(true);
}
if (qualifierTable.TryCreateQualifierForQualifierSpace(
pathTable,
loggingContext,
QualifierId,
targetQualifierSpaceId,
useDefaultsForCoercion,
out QualifierId resultingQualifierId,
out UnsupportedQualifierValue error))
{
qualifierValue = Create(resultingQualifierId, cache, qualifierTable, stringTable);
return(true);
}
var errorLocation = LocationData.Create(path, location.Line, location.Position);
error.Location = errorLocation.ToLogLocation(pathTable);
Logger.Log.ErrorUnsupportedQualifierValue(
loggingContext,
error.Location,
error.QualifierKey,
error.InvalidValue,
error.LegalValues);
return(false);
}
/// <summary>
/// Tries coercing qualifier.
/// </summary>
public bool TryCoerce(
QualifierSpaceId targetQualifierSpaceId,
QualifierTable qualifierTable,
QualifierValueCache cache,
PathTable pathTable,
StringTable stringTable,
LoggingContext loggingContext,
out QualifierValue qualifierValue,
LineInfo location,
bool useDefaultsForCoercion,
AbsolutePath path)
{
Contract.Requires(targetQualifierSpaceId.IsValid);
Contract.Requires(qualifierTable != null);
Contract.Requires(qualifierTable.IsValidQualifierSpaceId(targetQualifierSpaceId));
Contract.Requires(pathTable != null);
Contract.Requires(stringTable != null);
Contract.Requires(loggingContext != null);
qualifierValue = null;
if (targetQualifierSpaceId == qualifierTable.EmptyQualifierSpaceId)
{
qualifierValue = CreateEmpty(qualifierTable);
return(true);
}
if (qualifierTable.TryCreateQualifierForQualifierSpace(
pathTable,
loggingContext,
QualifierId,
targetQualifierSpaceId,
useDefaultsForCoercion,
out QualifierId resultingQualifierId,
out UnsupportedQualifierValue error))
{
qualifierValue = Create(resultingQualifierId, cache, qualifierTable, stringTable);
return(true);
}
var errorLocation = LocationData.Create(path, location.Line, location.Position);
error.Location = errorLocation.ToLogLocation(pathTable);
Logger.Log.ErrorUnsupportedQualifierValue(
loggingContext,
error.Location,
error.QualifierKey,
error.InvalidValue,
error.LegalValues);
return(false);
}
protected void BaseSetup(bool disablePipSerialization = false)
{
Directory.CreateDirectory(SourceRoot);
Directory.CreateDirectory(ObjectRoot);
QualifierTable = new QualifierTable(Context.StringTable);
ReadonlyRoot = Path.Combine(ObjectRoot, "readonly");
NonHashableRoot = Path.Combine(ObjectRoot, "nonhashable");
NonReadableRoot = Path.Combine(ObjectRoot, "nonreadable");
Directory.CreateDirectory(ReadonlyRoot);
Directory.CreateDirectory(NonHashableRoot);
Directory.CreateDirectory(NonReadableRoot);
}
/// <nodoc />
private FrontEndContext(PathTable pathTable, SymbolTable symbolTable, QualifierTable qualifierTable, LoggingContext loggingContext, IFileSystem fileSystem, CancellationToken cancellationToken)
: base(cancellationToken, pathTable.StringTable, pathTable, symbolTable, qualifierTable)
{
Contract.Requires(pathTable != null);
Contract.Requires(symbolTable != null);
Contract.Requires(loggingContext != null);
Contract.Requires(fileSystem != null);
Contract.Requires(qualifierTable != null);
Contract.Requires(pathTable.StringTable == symbolTable.StringTable);
Contract.Requires(pathTable.StringTable == qualifierTable.StringTable);
LoggingContext = loggingContext;
FileSystem = fileSystem;
PipDataBuilderPool = new ObjectPool <PipDataBuilder>(() => new PipDataBuilder(StringTable), builder => builder.Clear());
}
/// <summary>
/// Creates a qualifier value given a qualifier id.
/// </summary>
public static QualifierValue Create(
QualifierId qualifierId,
QualifierValueCache cache,
QualifierTable qualifierTable,
StringTable stringTable)
{
var result = cache.TryGet(qualifierId);
if (result == null)
{
result = Create(qualifierId, qualifierTable, stringTable);
cache.TryAdd(result);
}
return(result);
}
/// <summary>
/// Constructs a new instance
/// </summary>
public BuildXLTestContext(
StringTable stringTable,
PathTable pathTable,
SymbolTable symbolTable,
QualifierTable qualifierTable,
TokenTextTable tokenTextTable,
CancellationToken cancellationToken)
: base(
cancellationToken,
stringTable,
pathTable,
symbolTable,
qualifierTable,
tokenTextTable)
{
}
/// <summary>
/// Context used during schedule execution
/// </summary>
public SchedulerContext(
CancellationToken cancellationToken,
StringTable stringTable,
PathTable pathTable,
SymbolTable symbolTable,
QualifierTable qualifierTable)
: base(
cancellationToken,
stringTable,
pathTable,
symbolTable,
qualifierTable)
{
Contract.Requires(stringTable != null);
Contract.Requires(pathTable != null);
Contract.Requires(symbolTable != null);
Contract.Requires(qualifierTable != null);
}
private EngineState(
Guid graphId,
StringTable stringTable,
PathTable pathTable,
SymbolTable symbolTable,
QualifierTable qualifierTable,
PipTable pipTable,
PipGraph pipGraph,
MountPathExpander mountPathExpander,
SchedulerState schedulerState,
HistoricTableSizes historicTableSizes,
FileContentTable fileContentTable)
{
Contract.Requires(graphId != default(Guid), "GraphId is not unique enough to be represented in EngineState");
Contract.Requires(stringTable != null);
Contract.Requires(pathTable != null);
Contract.Requires(symbolTable != null);
Contract.Requires(qualifierTable != null);
Contract.Requires(stringTable == pathTable.StringTable);
Contract.Requires(pathTable.StringTable == symbolTable.StringTable);
Contract.Requires(pathTable.StringTable == qualifierTable.StringTable);
Contract.Requires(pipTable != null);
Contract.Requires(!pipTable.IsDisposed);
Contract.Requires(pipGraph != null);
Contract.Requires(mountPathExpander != null);
Contract.Requires(schedulerState != null);
Contract.Requires(historicTableSizes != null);
Contract.Requires(fileContentTable != null);
m_stringTable = stringTable;
m_pathTable = pathTable;
m_symbolTable = symbolTable;
m_qualifierTable = qualifierTable;
m_pipTable = pipTable;
m_pipGraph = pipGraph;
m_mountPathExpander = mountPathExpander;
m_schedulerState = schedulerState;
m_graphId = graphId;
m_historicTableSizes = historicTableSizes;
m_fileContentTable = fileContentTable;
}
/// <summary>
/// Creates a qualifier value given a qualifier id.
/// </summary>
public static QualifierValue Create(QualifierId qualifierId, QualifierTable qualifierTable, StringTable stringTable)
{
Contract.Requires(qualifierId.IsValid);
Contract.Requires(qualifierTable != null);
Contract.Requires(qualifierTable.IsValidQualifierId(qualifierId));
if (qualifierTable.EmptyQualifierId == qualifierId)
{
return(CreateEmpty(qualifierTable));
}
Qualifier qualifier = qualifierTable.GetQualifier(qualifierId);
var bindings = new List <Binding>(qualifier.Keys.Count);
for (int i = 0; i < qualifier.Keys.Count; ++i)
{
bindings.Add(new Binding(qualifier.Keys[i], qualifier.Values[i].ToString(stringTable), location: default(LineInfo)));
}
return(new QualifierValue(ObjectLiteral.Create(bindings, default(LineInfo), default(AbsolutePath)), qualifierId));
}
