public void ChoiceValueCaseDifferencesContributeToAmbiguousMatchTest() { ITemplateParameter param = new TemplateParameter( name: "TestName", type: "parameter", datatype: "choice", choices: new Dictionary <string, ParameterChoice>() { { "foot", new ParameterChoice("Foo", "Foo value") }, { "bar", new ParameterChoice("Bar", "Bar value") }, { "Football", new ParameterChoice("Football", "Foo value") }, { "FOOTPOUND", new ParameterChoice("Footpound", "Foo value") } }); IReadOnlyList <ITemplateParameter> parametersForTemplate = new List <ITemplateParameter>() { param }; ITemplateInfo templateInfo = A.Fake <ITemplateInfo>(); A.CallTo(() => templateInfo.Parameters).Returns(new List <ITemplateParameter>() { param }); string?canonical = TelemetryHelper.GetCanonicalValueForChoiceParamOrDefault(templateInfo, "TestName", "foo"); Assert.Null(canonical); }
NewProjectConfiguration CreateNewProjectConfig(string baseName, string templateId, string parameters) { FilePath solutionDirectory = Util.CreateTmpDir(baseName); CreateNuGetConfigFile(solutionDirectory); string projectName = GetProjectName(templateId); var config = new NewProjectConfiguration { CreateSolution = true, CreateProjectDirectoryInsideSolutionDirectory = true, CreateGitIgnoreFile = false, UseGit = false, Location = solutionDirectory, ProjectName = projectName, SolutionName = projectName }; foreach (var templateParameter in TemplateParameter.CreateParameters(parameters)) { config.Parameters [templateParameter.Name] = templateParameter.Value; } Directory.CreateDirectory(config.ProjectLocation); return(config); }
bool IsMoreSpecialized(ITypeDeclaration Spec, TemplateParameter t2, Dictionary <TemplateParameter, ISemantic> t1_DummyParamList) { AbstractType t1_TypeResults; // Make a type out of t1's specialization using (ctxt.Push(ctxt.ScopedBlock != null ? ctxt.ScopedBlock.Parent : null)) { var dict = ctxt.CurrentContext.DeducedTemplateParameters; // Make the T in e.g. T[] a virtual type so T will be replaced by it // T** will be X** then - so a theoretically valid type instead of a template param var dummyType = new ClassType(new DClassLike { Name = "X" }, null, null); foreach (var kv in t1_DummyParamList) { dict[kv.Key] = new TemplateParameterSymbol(t2, dummyType); } t1_TypeResults = Resolver.TypeResolution.TypeDeclarationResolver.ResolveSingle(Spec, ctxt); } if (t1_TypeResults == null) { return(true); } // Now try to fit the virtual Type t2 into t1 - and return true if it's possible return(new TemplateParameterDeduction(new DeducedTypeDictionary(), ctxt).Handle(t2, t1_TypeResults)); }
// Note: This method explicitly filters out "type" and "language", in addition to other filtering. public static IEnumerable <ITemplateParameter> FilterParamsForHelp(IEnumerable <ITemplateParameter> parameterDefinitions, HashSet <string> hiddenParams, bool showImplicitlyHiddenParams = false, bool hasPostActionScriptRunner = false, HashSet <string> parametersToAlwaysShow = null) { IList <ITemplateParameter> filteredParams = parameterDefinitions .Where(x => x.Priority != TemplateParameterPriority.Implicit && !hiddenParams.Contains(x.Name) && !string.Equals(x.Name, "type", StringComparison.OrdinalIgnoreCase) && !string.Equals(x.Name, "language", StringComparison.OrdinalIgnoreCase) && (showImplicitlyHiddenParams || x.DataType != "choice" || x.Choices.Count > 1 || (parametersToAlwaysShow?.Contains(x.Name) ?? false))).ToList(); // for filtering "tags" if (hasPostActionScriptRunner) { ITemplateParameter allowScriptsParam = new TemplateParameter() { Documentation = LocalizableStrings.WhetherToAllowScriptsToRun, Name = "allow-scripts", DataType = "choice", DefaultValue = "prompt", Choices = new Dictionary <string, string>() { { "yes", LocalizableStrings.AllowScriptsYesChoice }, { "no", LocalizableStrings.AllowScriptsNoChoice }, { "prompt", LocalizableStrings.AllowScriptsPromptChoice } } }; filteredParams.Add(allowScriptsParam); } return(filteredParams); }
public TemplateParameterSymbol(TemplateParameter tpn, ISemantic typeOrValue, ISyntaxRegion paramIdentifier = null) : base(tpn != null ? tpn.Representation : null, AbstractType.Get(typeOrValue), paramIdentifier) { IsKnowinglyUndetermined = TemplateInstanceHandler.IsNonFinalArgument(typeOrValue); this.Parameter = tpn; this.ParameterValue = typeOrValue as ISymbolValue; }
public static AST.TemplateParameter VisitTemplateParameter(TemplateParameter param) { var _param = new AST.TemplateParameter(); _param.Name = param.Name; return(_param); }
public override void VisitTemplateParameter(TemplateParameter tp) { if (tp.NameHash == searchHash && tp.Representation == symbol) { l.Add(tp); } }
static async Task CreateFromTemplateAndBuild(string basename, string templateId, string parameters, Action <Solution> preBuildChecks = null, bool checkExecutionTargets = false) { using (var ptt = new DotNetCoreProjectTemplateTest(basename, templateId)) { foreach (var templateParameter in TemplateParameter.CreateParameters(parameters)) { ptt.Config.Parameters [templateParameter.Name] = templateParameter.Value; } var template = await ptt.CreateAndBuild(preBuildChecks); CheckProjectTypeGuids(ptt.Solution, GetProjectTypeGuid(template)); // Blacklist library projects, which don't get any execution target if (checkExecutionTargets) { foreach (var p in ptt.Solution.GetAllProjects().OfType <DotNetProject> ()) { foreach (var config in p.Configurations) { var targets = p.GetExecutionTargets(config.Selector)?.ToList() ?? new List <ExecutionTarget> (); if (System.IO.Directory.Exists("/Applications/Safari.app")) { Assert.True(targets.Any(x => x.Name.Contains("Safari")), $"Configuration {config.Name} didn't contain Safari"); } if (System.IO.Directory.Exists("/Applications/Google Chrome.app")) { Assert.True(targets.Any(x => x.Name.Contains("Google Chrome")), $"Configuration {config.Name} didn't contain Chrome"); } } } } } }
public void ValidChoiceForParameterIsItsOwnCanonicalValueTest() { ITemplateParameter param = new TemplateParameter( name: "TestName", type: "parameter", datatype: "choice", choices: new Dictionary <string, ParameterChoice>() { { "foo", new ParameterChoice("Foo", "Foo value") }, { "bar", new ParameterChoice("Bar", "Bar value") } }); IReadOnlyList <ITemplateParameter> parametersForTemplate = new List <ITemplateParameter>() { param }; ITemplateInfo templateInfo = A.Fake <ITemplateInfo>(); A.CallTo(() => templateInfo.Parameters).Returns(new List <ITemplateParameter>() { param }); string?canonical = TelemetryHelper.GetCanonicalValueForChoiceParamOrDefault(templateInfo, "TestName", "foo"); Assert.Equal("foo", canonical); }
public void ChoiceValueCaseDifferenceIsAMatchTest() { ITemplateParameter param = new TemplateParameter( name: "TestName", type: "parameter", datatype: "choice", choices: new Dictionary <string, ParameterChoice>(StringComparer.OrdinalIgnoreCase) { { "foo", new ParameterChoice("Foo", "Foo value") }, { "bar", new ParameterChoice("Bar", "Bar value") } }); IReadOnlyList <ITemplateParameter> parametersForTemplate = new List <ITemplateParameter>() { param }; ITemplateInfo templateInfo = A.Fake <ITemplateInfo>(); A.CallTo(() => templateInfo.Parameters).Returns(new List <ITemplateParameter>() { param }); string?canonical = TelemetryHelper.GetCanonicalValueForChoiceParamOrDefault(templateInfo, "TestName", "FOO"); Assert.Equal("FOO", canonical); }
internal static bool IsSame(TemplateParameter derivedParam, TemplateParameter baseParam, EntityInstance baseTemplate) { if (baseParam.Constraint.Modifier.HasConst != derivedParam.Constraint.Modifier.HasConst) { return(false); } { HashSet <IEntityInstance> derived_bases = derivedParam.Constraint.BaseOfNames .Select(it => it.Evaluation.Components).ToHashSet(EntityInstance.ComparerI); IEnumerable <IEntityInstance> base_bases = baseParam.Constraint.BaseOfNames .Select(it => it.Evaluation.Components.TranslateThrough(baseTemplate)).ToArray(); if (!derived_bases.SetEquals(base_bases)) { return(false); } } { HashSet <IEntityInstance> derived_inherits = derivedParam.Constraint.InheritsNames .Select(it => it.Evaluation.Components).ToHashSet(EntityInstance.ComparerI); IEnumerable <IEntityInstance> base_inherits = baseParam.Constraint.InheritsNames .Select(it => it.Evaluation.Components.TranslateThrough(baseTemplate)).ToArray(); if (!derived_inherits.SetEquals(base_inherits)) { return(false); } } return(true); }
static bool CheckAndDeduceTypeAgainstTplParameter(TemplateParameter handledParameter, ISemantic argumentToCheck, DeducedTypeDictionary deducedTypes, ResolutionContext ctxt) { return(new Templates.TemplateParameterDeduction(deducedTypes, ctxt).Handle(handledParameter, argumentToCheck)); }
bool IsMoreSpecialized(TemplateParameter t1, TemplateParameter t2, Dictionary <TemplateParameter, ISemantic> t1_dummyParameterList) { if (t1 is TemplateTypeParameter && t2 is TemplateTypeParameter && !IsMoreSpecialized((TemplateTypeParameter)t1, (TemplateTypeParameter)t2, t1_dummyParameterList)) { return(false); } else if (t1 is TemplateValueParameter && t2 is TemplateValueParameter && !IsMoreSpecialized((TemplateValueParameter)t1, (TemplateValueParameter)t2)) { return(false); } else if (t1 is TemplateAliasParameter && t2 is TemplateAliasParameter && !IsMoreSpecialized((TemplateAliasParameter)t1, (TemplateAliasParameter)t2, t1_dummyParameterList)) { return(false); } else if (t1 is TemplateThisParameter && t2 is TemplateThisParameter && ! IsMoreSpecialized(((TemplateThisParameter)t1).FollowParameter, ((TemplateThisParameter)t2).FollowParameter, t1_dummyParameterList)) { return(false); } else if (t1 is TemplateAliasParameter && t2 is TemplateTypeParameter) { return(true); } return(false); }
public override void VisitTemplateParameter(TemplateParameter tp) { if (PushSelectionRange(tp)) { base.VisitTemplateParameter(tp); } }
public T Find <T>(TemplateParameter parameter, T defaultValue) { if (!_parameters.ContainsKey(parameter.ToString())) { return(defaultValue); } return((T)_parameters[parameter.ToString()]); }
public bool ContainsTemplateParameter(TemplateParameter p) { if(TemplateParameters != null) for(int i = 0; i < TemplateParameters.Length; i++) if(TemplateParameters[i] == p) return true; return false; }
public MockTemplateInfo WithParameters(params string[] parameters) { foreach (var param in parameters) { _parameters[param] = new TemplateParameter(param, "parameter", "string", priority: TemplateParameterPriority.Optional); } return(this); }
public int Create(TemplateParameter parameters) { var viewModel = MapFromClientParameters(parameters); var entity = viewModel.MapTo <Template>(); var savedEntity = MasterFileService.Add(entity); return(savedEntity.Id); }
protected virtual TemplateParameter GetParatmers() { var parameters = new TemplateParameter(); parameters.Add(RepositoryBuilderConstants.EntityName, GetEntityName); parameters.Add(RepositoryBuilderConstants.GetByUIdStp, $"[dbo].[{Entity.Entity.Name}_GetFullByUId]"); return(parameters); }
public void IndexOfFindsTemplate() { var collection = new TemplateParameterCollection(); var param = new TemplateParameter("test", "string", ""); collection.Add(param); Assert.AreEqual(0, collection.IndexOf(param)); }
private TemplateParameter TemplateParameters() { var parameters = new TemplateParameter(); parameters.Add(SqlConstants.TableName, Name); parameters.Add(SqlConstants.StpPropertyNames, string.Join("," + Environment.NewLine, GetSqlParameterNames()) + ","); return(parameters); }
public override Maybe <Link> ToHomeAccount() { var username = HttpContext?.User?.Identity?.Name; return (username == null?ToAction <HomeController>(x => x.AccountHome(TemplateParameter.Create <string>())) : ToAction <HomeController>(x => x.AccountHome(username))); }
/// <summary> /// Returns false if the item has already been set before and if the already set item is not equal to 'r'. /// Inserts 'r' into the target dictionary and returns true otherwise. /// </summary> bool Set(TemplateParameter p, ISemantic r, int nameHash) { if (p == null) { if (nameHash != 0 && TargetDictionary.ExpectedParameters != null) { foreach (var tpar in TargetDictionary.ExpectedParameters) { if (tpar.NameHash == nameHash) { p = tpar; break; } } } } if (p == null) { ctxt.LogError(null, "no fitting template parameter found!"); return(false); } // void call(T)(T t) {} // call(myA) -- T is *not* myA but A, so only assign myA's type to T. if (p is TemplateTypeParameter) { var newR = Resolver.TypeResolution.DResolver.StripMemberSymbols(AbstractType.Get(r)); if (newR != null) { r = newR; } } TemplateParameterSymbol rl; if (!TargetDictionary.TryGetValue(p, out rl) || rl == null) { TargetDictionary[p] = new TemplateParameterSymbol(p, r); return(true); } else { if (ResultComparer.IsEqual(rl.Base, r)) { TargetDictionary[p] = new TemplateParameterSymbol(p, r); return(true); } else if (rl == null) { TargetDictionary[p] = new TemplateParameterSymbol(p, r); } // Error: Ambiguous assignment return(false); } }
private TemplateParameter GetChangeTrackingParametersParameters(string description, string columnName, string tableName) { var parameters = new TemplateParameter(); parameters.Add(SqlConstants.TableName, tableName); parameters.Add(SqlConstants.Description, description); parameters.Add(SqlConstants.Columnname, columnName); return(parameters); }
private TemplateParameter GetParameters(bool isDelete) { var parameters = new TemplateParameter(); parameters.Add(SqlConstants.TableName, Name); parameters.Add(SqlConstants.StpPropertyNames, string.Join("," + Environment.NewLine, GetSqlParameterNames())); parameters.Add(SqlConstants.StpDeletetedPropertyNames, string.Join("," + Environment.NewLine, GetDeletedParameterNames(isDelete))); return(parameters); }
private TemplateParameter GetHistoryParameters() { var parameters = new TemplateParameter(); parameters.Add(SqlConstants.TableName, $"{Name}_historie"); parameters.Add(SqlConstants.Description, string.IsNullOrEmpty(Entity.Description) ? Name : Entity.Description); parameters.Add(SqlConstants.DescriptionColumns, GetHistoryColumnDescriptions); return(parameters); }
protected virtual TemplateParameter GetParameters() { var parameters = new TemplateParameter(); parameters.Add(SqlConstants.TableName, _entity.Name); parameters.Add(SqlConstants.Description, GetColumnDescription()); parameters.Add(SqlConstants.Columnname, _property.SelectSqlParameterNaam); return(parameters); }
private bool evalIsExpression_WithAliases(IsExpression isExpression, AbstractType typeToCheck) { /* * Note: It's needed to let the abstract ast scanner also scan through IsExpressions etc. * in order to find aliases and/or specified template parameters! */ var expectedTemplateParams = new TemplateParameter[isExpression.TemplateParameterList.Length + 1]; expectedTemplateParams [0] = isExpression.ArtificialFirstSpecParam; if (expectedTemplateParams.Length > 1) { isExpression.TemplateParameterList.CopyTo(expectedTemplateParams, 1); } var tpl_params = new DeducedTypeDictionary(expectedTemplateParams); var tpd = new TemplateParameterDeduction(tpl_params, ctxt); bool retTrue = false; if (isExpression.EqualityTest) // 6. { // a) if (isExpression.TypeSpecialization != null) { tpd.EnforceTypeEqualityWhenDeducing = true; retTrue = tpd.Handle(isExpression.ArtificialFirstSpecParam, typeToCheck); tpd.EnforceTypeEqualityWhenDeducing = false; } else // b) { var r = evalIsExpression_EvalSpecToken(isExpression, typeToCheck, true); retTrue = r.Item1; tpl_params[isExpression.TypeAliasIdentifierHash] = new TemplateParameterSymbol(null, r.Item2); } } else // 5. { retTrue = tpd.Handle(isExpression.ArtificialFirstSpecParam, typeToCheck); } if (retTrue && isExpression.TemplateParameterList != null) { foreach (var p in isExpression.TemplateParameterList) { if (!tpd.Handle(p, tpl_params[p.NameHash] != null ? tpl_params[p.NameHash].Base : null)) { return(false); } } } //TODO: Put all tpl_params results into the resolver context or make a new scope or something! return(retTrue); }
private TemplateParameter GetParameters() { var parameters = new TemplateParameter(); parameters.Add(SqlConstants.TableName, Entity.Name); parameters.Add(SqlConstants.TableProperties, GetTableProperties()); return(parameters); }
public TerminatingStringTemplate(string name, IEnumerable<TemplateParameter> parameters, int endingValue, int offsetMod, StringComparer stringComparer) { this.offsetMod = offsetMod;; this.parameter = parameters.First(); this.endingValue = BitConverter.GetBytes(endingValue).Take(parameter.LenghtInBytes).ToArray(); this.name = name; this.comparer = stringComparer; }
protected override TemplateParameter GetParameters() { var parameters = new TemplateParameter(); parameters.Add(SqlConstants.TableName, $"{_entity.Name}_historie"); parameters.Add(SqlConstants.Description, GetColumnDescription()); parameters.Add(SqlConstants.Columnname, _property.SelectSqlParameterNaam); return(parameters); }
public void RemoveRemovesTemplate() { var collection = new TemplateParameterCollection(); var param = new TemplateParameter("test", "string", ""); collection.Add(param); Assert.AreEqual(1, collection.Count); collection.Remove(param); Assert.AreEqual(0, collection.Count); }
public bool TryGetTemplateParameter(int nameHash, out TemplateParameter p) { if (TemplateParameters != null) for (int i = 0; i < TemplateParameters.Length; i++) if (TemplateParameters[i].NameHash == nameHash) { p = TemplateParameters[i]; return true; } p = null; return false; }
private bool evalIsExpression_WithAliases(IsExpression isExpression, AbstractType typeToCheck) { /* * Note: It's needed to let the abstract ast scanner also scan through IsExpressions etc. * in order to find aliases and/or specified template parameters! */ var expectedTemplateParams = new TemplateParameter[isExpression.TemplateParameterList == null ? 1 : (isExpression.TemplateParameterList.Length + 1)]; expectedTemplateParams [0] = isExpression.ArtificialFirstSpecParam; if(expectedTemplateParams.Length > 1) isExpression.TemplateParameterList.CopyTo (expectedTemplateParams, 1); var tpl_params = new DeducedTypeDictionary(expectedTemplateParams); var tpd = new TemplateParameterDeduction(tpl_params, ctxt); bool retTrue = false; if (isExpression.EqualityTest) // 6. { // a) if (isExpression.TypeSpecialization != null) { tpd.EnforceTypeEqualityWhenDeducing = true; retTrue = tpd.Handle(isExpression.ArtificialFirstSpecParam, typeToCheck); tpd.EnforceTypeEqualityWhenDeducing = false; } else // b) { var r = evalIsExpression_EvalSpecToken(isExpression, typeToCheck, true); retTrue = r.Item1; tpl_params[isExpression.ArtificialFirstSpecParam] = new TemplateParameterSymbol(isExpression.ArtificialFirstSpecParam, r.Item2); } } else // 5. retTrue = tpd.Handle(isExpression.ArtificialFirstSpecParam, typeToCheck); if (retTrue && isExpression.TemplateParameterList != null) foreach (var p in isExpression.TemplateParameterList) if (!tpd.Handle(p, tpl_params[p] != null ? tpl_params[p].Base : null)) return false; if (retTrue) { foreach (var kv in tpl_params) ctxt.CurrentContext.DeducedTemplateParameters[kv.Key] = kv.Value; } return retTrue; }
public bool Handle(TemplateParameter parameter, ISemantic argumentToAnalyze) { // Packages aren't allowed at all if (argumentToAnalyze is PackageSymbol) return false; // Module symbols can be used as alias only if (argumentToAnalyze is ModuleSymbol && !(parameter is TemplateAliasParameter)) return false; //TODO: Handle __FILE__ and __LINE__ correctly - so don't evaluate them at the template declaration but at the point of instantiation /* * Introduce previously deduced parameters into current resolution context * to allow value parameter to be of e.g. type T whereas T is already set somewhere before */ DeducedTypeDictionary _prefLocalsBackup = null; if (ctxt != null && ctxt.CurrentContext != null) { _prefLocalsBackup = ctxt.CurrentContext.DeducedTemplateParameters; var d = new DeducedTypeDictionary(); foreach (var kv in TargetDictionary) if (kv.Value != null) d[kv.Key] = kv.Value; ctxt.CurrentContext.DeducedTemplateParameters = d; } bool res = false; if (parameter is TemplateAliasParameter) res = Handle((TemplateAliasParameter)parameter, argumentToAnalyze); else if (parameter is TemplateThisParameter) res = Handle((TemplateThisParameter)parameter, argumentToAnalyze); else if (parameter is TemplateTypeParameter) res = Handle((TemplateTypeParameter)parameter, argumentToAnalyze); else if (parameter is TemplateValueParameter) res = Handle((TemplateValueParameter)parameter, argumentToAnalyze); else if (parameter is TemplateTupleParameter) res = Handle((TemplateTupleParameter)parameter, new[] { argumentToAnalyze }); if (ctxt != null && ctxt.CurrentContext != null) ctxt.CurrentContext.DeducedTemplateParameters = _prefLocalsBackup; return res; }
private bool evalIsExpression_WithAliases(IsExpression isExpression, AbstractType typeToCheck) { /* * Note: It's needed to let the abstract ast scanner also scan through IsExpressions etc. * in order to find aliases and/or specified template parameters! */ var expectedTemplateParams = new TemplateParameter[isExpression.TemplateParameterList.Length + 1]; expectedTemplateParams [0] = isExpression.ArtificialFirstSpecParam; if(expectedTemplateParams.Length > 1) isExpression.TemplateParameterList.CopyTo (expectedTemplateParams, 1); var tpl_params = new DeducedTypeDictionary(expectedTemplateParams); var tpd = new TemplateParameterDeduction(tpl_params, ctxt); bool retTrue = false; if (isExpression.EqualityTest) // 6. { // a) if (isExpression.TypeSpecialization != null) { tpd.EnforceTypeEqualityWhenDeducing = true; retTrue = tpd.Handle(isExpression.ArtificialFirstSpecParam, typeToCheck); tpd.EnforceTypeEqualityWhenDeducing = false; } else // b) { var r = evalIsExpression_EvalSpecToken(isExpression, typeToCheck, true); retTrue = r.Item1; tpl_params[isExpression.TypeAliasIdentifierHash] = new TemplateParameterSymbol(null, r.Item2); } } else // 5. retTrue = tpd.Handle(isExpression.ArtificialFirstSpecParam, typeToCheck); if (retTrue && isExpression.TemplateParameterList != null) foreach (var p in isExpression.TemplateParameterList) if (!tpd.Handle(p, tpl_params[p.NameHash] != null ? tpl_params[p.NameHash].Base : null)) return false; //TODO: Put all tpl_params results into the resolver context or make a new scope or something! return retTrue; }
protected TemplateParameter(TemplateParameter.Internal* native, bool skipVTables = false) { if (native == null) return; __Instance = new global::System.IntPtr(native); }
private TemplateParameter(TemplateParameter.Internal native, bool skipVTables = false) : this(__CopyValue(native), skipVTables) { __ownsNativeInstance = true; NativeToManagedMap[__Instance] = this; }
public static TemplateParameter __CreateInstance(TemplateParameter.Internal native, bool skipVTables = false) { return new TemplateParameter(native, skipVTables); }
private static void* __CopyValue(TemplateParameter.__Internal native) { var ret = Marshal.AllocHGlobal(140); global::CppSharp.Parser.AST.TemplateParameter.__Internal.cctor_1(ret, new global::System.IntPtr(&native)); return ret.ToPointer(); }
bool IsMoreSpecialized(TemplateParameter t1, TemplateParameter t2, Dictionary<TemplateParameter, ISemantic> t1_dummyParameterList) { if (t1 is TemplateTypeParameter && t2 is TemplateTypeParameter && !IsMoreSpecialized((TemplateTypeParameter)t1, (TemplateTypeParameter)t2, t1_dummyParameterList)) return false; else if (t1 is TemplateValueParameter && t2 is TemplateValueParameter && !IsMoreSpecialized((TemplateValueParameter)t1, (TemplateValueParameter)t2)) return false; else if (t1 is TemplateAliasParameter && t2 is TemplateAliasParameter && !IsMoreSpecialized((TemplateAliasParameter)t1, (TemplateAliasParameter)t2, t1_dummyParameterList)) return false; else if (t1 is TemplateThisParameter && t2 is TemplateThisParameter && ! IsMoreSpecialized(((TemplateThisParameter)t1).FollowParameter, ((TemplateThisParameter)t2).FollowParameter, t1_dummyParameterList)) return false; else if (t1 is TemplateAliasParameter && t2 is TemplateTypeParameter) return true; return false; }
/// <summary> /// Returns false if the item has already been set before and if the already set item is not equal to 'r'. /// Inserts 'r' into the target dictionary and returns true otherwise. /// </summary> bool Set(TemplateParameter p, ISemantic r, int nameHash) { if (p == null) { if (nameHash != 0 && TargetDictionary.ExpectedParameters != null) { foreach (var tpar in TargetDictionary.ExpectedParameters) if (tpar.NameHash == nameHash) { p = tpar; break; } } } if (p == null) { ctxt.LogError (null, "no fitting template parameter found!"); return false; } // void call(T)(T t) {} // call(myA) -- T is *not* myA but A, so only assign myA's type to T. if (p is TemplateTypeParameter) { var newR = Resolver.TypeResolution.DResolver.StripMemberSymbols(AbstractType.Get(r)); if (newR != null) r = newR; } TemplateParameterSymbol rl; if (!TargetDictionary.TryGetValue(p, out rl) || rl == null) { TargetDictionary[p] = new TemplateParameterSymbol(p, r); return true; } else { if (ResultComparer.IsEqual(rl.Base, r)) { return true; } else { // Error: Ambiguous assignment } TargetDictionary[p] = new TemplateParameterSymbol(p, r); return false; } }
public static bool HasDefaultType(TemplateParameter p) { if (p is TemplateTypeParameter) return ((TemplateTypeParameter)p).Default != null; else if (p is TemplateAliasParameter) { var ap = (TemplateAliasParameter)p; return ap.DefaultExpression != null || ap.DefaultType != null; } else if (p is TemplateThisParameter) return HasDefaultType(((TemplateThisParameter)p).FollowParameter); else if (p is TemplateValueParameter) return ((TemplateValueParameter)p).DefaultExpression != null; return false; }
internal TemplateParameter(TemplateParameter.Internal* native) : this(new global::System.IntPtr(native)) { }
internal TemplateParameter(TemplateParameter.Internal native) : this(&native) { }
static bool CheckAndDeduceTypeAgainstTplParameter(TemplateParameter handledParameter, ISemantic argumentToCheck, DeducedTypeDictionary deducedTypes, ResolutionContext ctxt) { return new Templates.TemplateParameterDeduction(deducedTypes, ctxt).Handle(handledParameter, argumentToCheck); }
private TemplateParameter(TemplateParameter.Internal native) : this(__CopyValue(native)) { __ownsNativeInstance = true; NativeToManagedMap[__Instance] = this; }
public static TemplateParameter __CreateInstance(TemplateParameter.Internal native) { return new TemplateParameter(native); }
public virtual void Visit(TemplateParameter.Node n) { VisitDNode(n); n.TemplateParameter.Accept(this); }
public override void VisitTemplateParameter(TemplateParameter tp) { AddResult (tp, DTokens.Not); }
public virtual void VisitTemplateParameter(TemplateParameter tp) { }
public TemplateParameterSymbol(TemplateParameter tpn, ISemantic typeOrValue, ISyntaxRegion paramIdentifier = null) : base(tpn != null ? tpn.Representation : null, AbstractType.Get(typeOrValue), paramIdentifier) { this.Parameter = tpn; this.ParameterValue = typeOrValue as ISymbolValue; }
public override void VisitTemplateParameter(TemplateParameter tp) { if (tp.NameHash == searchHash && tp.Representation == symbol) l.Add (tp); }
bool IsMoreSpecialized(ITypeDeclaration Spec, TemplateParameter t2, Dictionary<int, ISemantic> t1_DummyParamList) { // Make a type out of t1's specialization var pop = ctxt.ScopedBlock != null; if(pop) ctxt.PushNewScope(ctxt.ScopedBlock.Parent as IBlockNode); var frame = ctxt.CurrentContext; // Make the T in e.g. T[] a virtual type so T will be replaced by it // T** will be X** then - so a theoretically valid type instead of a template param var dummyType = new ClassType(new DClassLike { Name = "X" }, null, null); foreach (var kv in t1_DummyParamList) frame.DeducedTemplateParameters[kv.Key] = new TemplateParameterSymbol(t2,dummyType); var t1_TypeResults = Resolver.TypeResolution.TypeDeclarationResolver.Resolve(Spec, ctxt); if(pop) ctxt.Pop(); if (t1_TypeResults == null || t1_TypeResults.Length == 0) return true; // Now try to fit the virtual Type t2 into t1 - and return true if it's possible return new TemplateParameterDeduction(new DeducedTypeDictionary(), ctxt).Handle(t2, t1_TypeResults[0]); }
bool IsMoreSpecialized(ITypeDeclaration Spec, TemplateParameter t2, Dictionary<TemplateParameter, ISemantic> t1_DummyParamList) { AbstractType t1_TypeResults; // Make a type out of t1's specialization using (ctxt.Push(ctxt.ScopedBlock != null ? ctxt.ScopedBlock.Parent : null)) { var dict = ctxt.CurrentContext.DeducedTemplateParameters; // Make the T in e.g. T[] a virtual type so T will be replaced by it // T** will be X** then - so a theoretically valid type instead of a template param var dummyType = new ClassType(new DClassLike { Name = "X" }, null, null); foreach (var kv in t1_DummyParamList) dict[kv.Key] = new TemplateParameterSymbol(t2, dummyType); t1_TypeResults = Resolver.TypeResolution.TypeDeclarationResolver.ResolveSingle(Spec, ctxt); } if (t1_TypeResults == null) return true; // Now try to fit the virtual Type t2 into t1 - and return true if it's possible return new TemplateParameterDeduction(new DeducedTypeDictionary(), ctxt).Handle(t2, t1_TypeResults); }
private static bool DeduceParam(ResolutionContext ctxt, DSymbol overload, DeducedTypeDictionary deducedTypes, IEnumerator<ISemantic> argEnum, TemplateParameter expectedParam) { if (expectedParam is TemplateThisParameter && overload.Base != null) { var ttp = (TemplateThisParameter)expectedParam; // Get the type of the type of 'this' - so of the result that is the overload's base var t = DResolver.StripMemberSymbols(overload.Base); if (t == null || t.DeclarationOrExpressionBase == null) return false; //TODO: Still not sure if it's ok to pass a type result to it // - looking at things like typeof(T) that shall return e.g. const(A) instead of A only. if (!CheckAndDeduceTypeAgainstTplParameter(ttp, t, deducedTypes, ctxt)) return false; return true; } // Used when no argument but default arg given bool useDefaultType = false; if (argEnum.MoveNext() || (useDefaultType = HasDefaultType(expectedParam))) { // On tuples, take all following arguments and pass them to the check function if (expectedParam is TemplateTupleParameter) { var tupleItems = new List<ISemantic>(); // A tuple must at least contain one item! tupleItems.Add(argEnum.Current); while (argEnum.MoveNext()) tupleItems.Add(argEnum.Current); if (!CheckAndDeduceTypeTuple((TemplateTupleParameter)expectedParam, tupleItems, deducedTypes, ctxt)) return false; } else if (argEnum.Current != null) { if (!CheckAndDeduceTypeAgainstTplParameter(expectedParam, argEnum.Current, deducedTypes, ctxt)) return false; } else if (useDefaultType && CheckAndDeduceTypeAgainstTplParameter(expectedParam, null, deducedTypes, ctxt)) { // It's legit - just do nothing } else return false; } else if(expectedParam is TemplateTupleParameter) { if(!CheckAndDeduceTypeTuple(expectedParam as TemplateTupleParameter, null, deducedTypes, ctxt)) return false; } // There might be too few args - but that doesn't mean that it's not correct - it's only required that all parameters got satisfied with a type else if (!deducedTypes.AllParamatersSatisfied) return false; return true; }
private static TemplateParameter.Internal* __CopyValue(TemplateParameter.Internal native) { var ret = Marshal.AllocHGlobal(32); CppSharp.Parser.AST.TemplateParameter.Internal.cctor_1(ret, new global::System.IntPtr(&native)); return (TemplateParameter.Internal*) ret; }
internal TemplateParameter(TemplateParameter.Internal native) : this(__CopyValue(native)) { }
protected TemplateParameter(TemplateParameter.Internal* native, bool isInternalImpl = false) { __Instance = new global::System.IntPtr(native); }
private TemplateParameter(TemplateParameter.Internal native) : this(__CopyValue(native)) { __ownsNativeInstance = true; }