public NamedValue Eval(Context context, ModuleLiteral env, EvaluationStackFrame args)
{
if (!IsValid)
{
return(this);
}
var result = ObjectLiteral.EvalExpression(context, env, Value, args);
return(new NamedValue(NameId, result));
}
private static bool TryCreate(
ImmutableContextBase context,
ModuleLiteral env,
out QualifierValue qualifierValue,
LineInfo lineInfo,
ObjectLiteral objectLiteral)
{
Contract.Requires(context != null);
Contract.Requires(env != null);
Contract.Requires(objectLiteral != null);
qualifierValue = null;
if (objectLiteral.Count == 0)
{
qualifierValue = CreateEmpty(context.FrontEndContext.QualifierTable);
return(true);
}
Tuple <StringId, StringId>[] qualifierKvps = new Tuple <StringId, StringId> [objectLiteral.Count];
int i = 0;
foreach (var kvp in objectLiteral.Members)
{
if (!(kvp.Value.Value is string value))
{
var location = lineInfo.AsUniversalLocation(env, context);
var error = new ErrorContext(name: kvp.Key, objectCtx: objectLiteral).ToErrorString(context);
context.Logger.ReportQualifierValueMustEvaluateToString(context.LoggingContext, location.AsLoggingLocation(), error, context.GetStackTraceAsErrorMessage(location));
return(false);
}
qualifierKvps[i] = Tuple.Create(kvp.Key, context.FrontEndContext.StringTable.AddString(value));
++i;
}
QualifierId qualifierId = context.FrontEndContext.QualifierTable.CreateQualifier(qualifierKvps);
qualifierValue = new QualifierValue(objectLiteral, qualifierId);
return(true);
}
/// <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));
}
private LazyEvalObjectLiteral(ObjectLiteral literal, string returnType) : base(literal.Location, literal.Path)
{
m_literal = literal;
ReturnType = returnType;
}
/// <nodoc/>
public static ObjectLiteral Create(IReadOnlyList <Binding> bindings, LineInfo location, AbsolutePath path, string returnType)
{
return(new LazyEvalObjectLiteral(ObjectLiteral.Create(bindings, location, path), returnType));
}
/// <nodoc />
internal QualifierValue(ObjectLiteral qualifier, QualifierId qualifierId)
{
Qualifier = qualifier;
QualifierId = qualifierId;
}
protected MergeFunction GetMergeFunction(Context context, EvaluationStackFrame captures, ObjectLiteral leftObject, EvaluationResult rightObject)
{
// If the left object has a custom merge, that trumps the other cases
var customMergeLeft = leftObject.TryGetCustomMergeFunction(context, captures);
if (customMergeLeft != null)
{
return(customMergeLeft);
}
// Otherwise if the right object has a custom merge, then use that one
if (rightObject.Value is ObjectLiteral rightObjectLiteral)
{
var customMergeRight = rightObjectLiteral.TryGetCustomMergeFunction(context, captures);
if (customMergeRight != null)
{
return(customMergeRight);
}
}
// Otherwise, use the default merge function
return(GetDefaultMergeFunction(context, captures));
}
