/// <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; }