internal RealObjectCollectorResult(StObjObjectEngineMap mappings, IReadOnlyList <IReadOnlyList <MutableItem> > concreteClasses, IReadOnlyList <IReadOnlyList <Type> > classAmbiguities, IReadOnlyList <IReadOnlyList <Type> > interfaceAmbiguities, IReadOnlyList <Type> abstractTails) { EngineMap = mappings; _concreteClassesPath = concreteClasses; ClassAmbiguities = classAmbiguities; InterfaceAmbiguities = interfaceAmbiguities; AbstractTails = abstractTails; }
internal virtual MutableItem?ResolveToStObj(IActivityMonitor monitor, StObjObjectEngineMap collector) { MutableItem?result = null; if (Type != null && StObjRequirementBehavior != StObjRequirementBehavior.ExternalReference) { result = collector.ToHighestImpl(Type); if (result == null) { // No warn on value type or string not found. WarnOrErrorIfStObjRequired(monitor, skipWarnOnValueType: true, text: $"{Type.FullName} not found"); } } return(result); }
internal override MutableItem?ResolveToStObj(IActivityMonitor monitor, StObjObjectEngineMap collector) { if (_resolved != UnresolvedMarker) { return(_resolved); } if (Type == null && !IsOptional) { Error(monitor, $"Type can not be null since the {KindName} is not optional"); return(_resolved = null); } Debug.Assert(Type != null || IsOptional); if (Type != null && !UnderlyingType.IsAssignableFrom(Type)) { Error(monitor, $"Type '{Type.FullName}' is not compatible with the {KindName} type ('{UnderlyingType.FullName}')"); return(_resolved = null); } return(_resolved = base.ResolveToStObj(monitor, collector)); }
RealObjectCollectorResult GetRealObjectResult() { List <MutableItem> allSpecializations = new List <MutableItem>(_roots.Count); StObjObjectEngineMap engineMap = new StObjObjectEngineMap(_names, allSpecializations, KindDetector, _assemblies); List <List <MutableItem> > concreteClasses = new List <List <MutableItem> >(); List <IReadOnlyList <Type> >?classAmbiguities = null; List <Type> abstractTails = new List <Type>(); var deepestConcretes = new List <(MutableItem, ImplementableTypeInfo)>(); Debug.Assert(_roots.All(info => info != null && !info.IsExcluded && info.Generalization == null), "_roots contains only not Excluded types."); foreach (RealObjectClassInfo newOne in _roots) { deepestConcretes.Clear(); newOne.CreateMutableItemsPath(_monitor, _serviceProvider, engineMap, null, _tempAssembly, deepestConcretes, abstractTails); if (deepestConcretes.Count == 1) { MutableItem last = deepestConcretes[0].Item1; allSpecializations.Add(last); var path = new List <MutableItem>(); last.InitializeBottomUp(null); path.Add(last); MutableItem?spec = last, toInit = last; while ((toInit = toInit.Generalization) != null) { toInit.InitializeBottomUp(spec); path.Add(toInit); spec = toInit; } path.Reverse(); concreteClasses.Add(path); foreach (var m in path) { engineMap.AddClassMapping(m.RealObjectType.Type, last); } } else if (deepestConcretes.Count > 1) { List <Type> ambiguousPath = new List <Type>() { newOne.Type }; ambiguousPath.AddRange(deepestConcretes.Select(m => m.Item1.RealObjectType.Type)); if (classAmbiguities == null) { classAmbiguities = new List <IReadOnlyList <Type> >(); } classAmbiguities.Add(ambiguousPath.ToArray()); } } Dictionary <Type, List <Type> >?interfaceAmbiguities = null; foreach (var path in concreteClasses) { MutableItem finalType = path[path.Count - 1]; finalType.RealObjectType.InitializeInterfaces(_monitor, this); foreach (var item in path) { foreach (Type itf in item.RealObjectType.ThisRealObjectInterfaces) { MutableItem?alreadyMapped; if ((alreadyMapped = engineMap.RawMappings.GetValueOrDefault(itf)) != null) { if (interfaceAmbiguities == null) { interfaceAmbiguities = new Dictionary <Type, List <Type> > { { itf, new List <Type>() { itf, alreadyMapped.RealObjectType.Type, item.RealObjectType.Type } } }; } else { var list = interfaceAmbiguities.GetOrSet(itf, t => new List <Type>() { itf, alreadyMapped.RealObjectType.Type }); list.Add(item.RealObjectType.Type); } } else { engineMap.AddInterfaceMapping(itf, item, finalType); } } } } return(new RealObjectCollectorResult(engineMap, concreteClasses, classAmbiguities ?? (IReadOnlyList <IReadOnlyList <Type> >)Array.Empty <IReadOnlyList <Type> >(), interfaceAmbiguities != null ? interfaceAmbiguities.Values.Select(list => list.ToArray()).ToArray() : Array.Empty <IReadOnlyList <Type> >(), abstractTails)); }
internal override MutableItem?ResolveToStObj(IActivityMonitor monitor, StObjObjectEngineMap collector) { return(IsSetupLogger ? null : base.ResolveToStObj(monitor, collector)); }