/// <summary>
/// Uses the standard value provider for expression value evaluation
/// </summary>
public static ISymbolValue EvaluateValue (IExpression x, ResolutionContext ctxt, bool lazyVariableValueEvaluation = false)
{
try
{
var vp = new StandardValueProvider (ctxt);
var v = EvaluateValue (x, vp);
if (v is VariableValue && !lazyVariableValueEvaluation) {
return EvaluateValue (v as VariableValue, vp);
}
return v;
}
catch (Exception ex)
{
return new ErrorValue(new EvaluationException(x, ex.Message + "\n\n" + ex.StackTrace));
}
}
public static ISymbolValue EvaluateValue(IExpression x, AbstractSymbolValueProvider vp)
{
if (vp == null)
{
vp = new StandardValueProvider(null);
}
var ev = new Evaluation(vp);
var v = ev.E(x) as ISymbolValue;
if (v == null && ev.Errors.Count != 0)
{
return(new ErrorValue(ev.Errors.ToArray()));
}
return(v);
}
/// <summary>
/// Uses the standard value provider for expression value evaluation
/// </summary>
public static ISymbolValue EvaluateValue(IExpression x, ResolutionContext ctxt, bool lazyVariableValueEvaluation = false)
{
try
{
var vp = new StandardValueProvider(ctxt);
var v = EvaluateValue(x, vp);
if (v is VariableValue && !lazyVariableValueEvaluation)
{
return(EvaluateValue(v as VariableValue, vp));
}
return(v);
}
catch (Exception ex)
{
return(new ErrorValue(new EvaluationException(x, ex.Message + "\n\n" + ex.StackTrace)));
}
}
public static ISymbolValue EvaluateValue(IExpression x, AbstractSymbolValueProvider vp)
{
if (vp == null)
vp = new StandardValueProvider(null);
var ev = new Evaluation(vp);
var v = ev.E(x) as ISymbolValue;
if(v == null && ev.Errors.Count != 0)
return new ErrorValue(ev.Errors.ToArray());
return v;
}
public static List<ISemantic> PreResolveTemplateArgs(TemplateInstanceExpression tix, ResolutionContext ctxt, out bool hasNonFinalArgument)
{
hasNonFinalArgument = false;
// Resolve given argument expressions
var templateArguments = new List<ISemantic>();
if (tix != null && tix.Arguments!=null)
foreach (var arg in tix.Arguments)
{
if (arg is TypeDeclarationExpression)
{
var tde = (TypeDeclarationExpression)arg;
var res = TypeDeclarationResolver.Resolve(tde.Declaration, ctxt);
if (ctxt.CheckForSingleResult(res, tde.Declaration) || res != null)
{
var mr = res[0] as MemberSymbol;
if (mr != null && mr.Definition is DVariable)
{
var dv = (DVariable)mr.Definition;
if (dv.IsAlias || dv.Initializer == null)
{
templateArguments.Add(mr);
continue;
}
ISemantic eval = null;
try
{
eval = new StandardValueProvider(ctxt)[dv];
}
catch(System.Exception ee) // Should be a non-const-expression error here only
{
ctxt.LogError(dv.Initializer, ee.Message);
}
templateArguments.Add(eval==null ? (ISemantic)mr : eval);
}
else{
if(!hasNonFinalArgument)
hasNonFinalArgument = IsNonFinalArgument(res[0]);
templateArguments.Add(res[0]);
}
}
}
else
{
var v = Evaluation.EvaluateValue(arg, ctxt, true);
if (v is VariableValue)
{
var vv = v as VariableValue;
if (vv.Variable.IsConst && vv.Variable.Initializer != null)
v = Evaluation.EvaluateValue(vv, new StandardValueProvider(ctxt));
}
if(!hasNonFinalArgument)
hasNonFinalArgument = IsNonFinalArgument(v);
templateArguments.Add(v);
}
}
return templateArguments;
}
/// <summary>
/// Associates the given arguments with the template parameters specified in the type/method declarations
/// and filters out unmatching overloads.
/// </summary>
/// <param name="rawOverloadList">Can be either type results or method results</param>
/// <param name="givenTemplateArguments">A list of already resolved arguments passed explicitly
/// in the !(...) section of a template instantiation
/// or call arguments given in the (...) appendix
/// that follows a method identifier</param>
/// <param name="isMethodCall">If true, arguments that exceed the expected parameter count will be ignored as far as all parameters could be satisfied.</param>
/// <param name="ctxt"></param>
/// <returns>A filtered list of overloads which mostly fit to the specified arguments.
/// Usually contains only 1 element.
/// The 'TemplateParameters' property of the results will be also filled for further usage regarding smart completion etc.</returns>
public static AbstractType[] DeduceParamsAndFilterOverloads(IEnumerable<AbstractType> rawOverloadList,
IEnumerable<ISemantic> givenTemplateArguments,
bool isMethodCall,
ResolutionContext ctxt,
bool hasUndeterminedArguments=false)
{
if (rawOverloadList == null)
return null;
var filteredOverloads = hasUndeterminedArguments ? new List<AbstractType>(rawOverloadList) :
DeduceOverloads(rawOverloadList, givenTemplateArguments, isMethodCall, ctxt);
AbstractType[] sortedAndFilteredOverloads;
// If there are >1 overloads, filter from most to least specialized template param
if (filteredOverloads.Count > 1)
sortedAndFilteredOverloads = SpecializationOrdering.FilterFromMostToLeastSpecialized(filteredOverloads, ctxt);
else if (filteredOverloads.Count == 1)
sortedAndFilteredOverloads = new[] { filteredOverloads[0] };
else
return null;
if (hasUndeterminedArguments)
return sortedAndFilteredOverloads;
if(sortedAndFilteredOverloads!=null)
{
filteredOverloads.Clear();
for(int i = sortedAndFilteredOverloads.Length - 1; i >= 0; i--)
{
var ds = sortedAndFilteredOverloads[i] as DSymbol;
if(ds != null && ds.Definition.TemplateConstraint != null)
{
ctxt.CurrentContext.IntroduceTemplateParameterTypes(ds);
try{
var v = Evaluation.EvaluateValue(ds.Definition.TemplateConstraint, ctxt);
if(v is VariableValue)
v = new StandardValueProvider(ctxt)[((VariableValue)v).Variable];
if(!Evaluation.IsFalseZeroOrNull(v))
filteredOverloads.Add(ds);
}catch{} //TODO: Handle eval exceptions
ctxt.CurrentContext.RemoveParamTypesFromPreferredLocals(ds);
}
else
filteredOverloads.Add(sortedAndFilteredOverloads[i]);
}
if(filteredOverloads.Count == 0)
return null;
sortedAndFilteredOverloads = filteredOverloads.ToArray();
}
if (sortedAndFilteredOverloads != null &&
sortedAndFilteredOverloads.Length == 1)
{
var t = sortedAndFilteredOverloads [0];
if(t is TemplateType)
return TryGetImplicitProperty (t as TemplateType, ctxt) ?? sortedAndFilteredOverloads;
if (t is EponymousTemplateType)
return new[]{ DeduceEponymousTemplate(t as EponymousTemplateType, ctxt) };
}
return sortedAndFilteredOverloads;
}
