source: tags/3.3.13/HeuristicLab.ExtLibs/HeuristicLab.NRefactory/5.5.0/NRefactory-5.5.0/TypeSystem/Implementation/DefaultResolvedTypeParameter.cs @ 18242

// Copyright (c) 2010-2013 AlphaSierraPapa for the SharpDevelop Team
// 
// Permission is hereby granted, free of charge, to any person obtaining a copy of this
// software and associated documentation files (the "Software"), to deal in the Software
// without restriction, including without limitation the rights to use, copy, modify, merge,
// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons
// to whom the Software is furnished to do so, subject to the following conditions:
// 
// The above copyright notice and this permission notice shall be included in all copies or
// substantial portions of the Software.
// 
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
// DEALINGS IN THE SOFTWARE.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using ICSharpCode.NRefactory.Utils;

namespace ICSharpCode.NRefactory.TypeSystem.Implementation
{
  public class DefaultTypeParameter : AbstractTypeParameter
  {
    readonly bool hasValueTypeConstraint;
    readonly bool hasReferenceTypeConstraint;
    readonly bool hasDefaultConstructorConstraint;
    readonly IList<IType> constraints;
    
    public DefaultTypeParameter(
      IEntity owner,
      int index, string name = null,
      VarianceModifier variance = VarianceModifier.Invariant,
      IList<IAttribute> attributes = null,
      DomRegion region = default(DomRegion),
      bool hasValueTypeConstraint = false, bool hasReferenceTypeConstraint = false, bool hasDefaultConstructorConstraint = false,
      IList<IType> constraints = null)
      : base(owner, index, name, variance, attributes, region)
    {
      this.hasValueTypeConstraint = hasValueTypeConstraint;
      this.hasReferenceTypeConstraint = hasReferenceTypeConstraint;
      this.hasDefaultConstructorConstraint = hasDefaultConstructorConstraint;
      this.constraints = constraints ?? EmptyList<IType>.Instance;
    }
    
    public DefaultTypeParameter(
      ICompilation compilation, SymbolKind ownerType,
      int index, string name = null,
      VarianceModifier variance = VarianceModifier.Invariant,
      IList<IAttribute> attributes = null,
      DomRegion region = default(DomRegion),
      bool hasValueTypeConstraint = false, bool hasReferenceTypeConstraint = false, bool hasDefaultConstructorConstraint = false,
      IList<IType> constraints = null)
      : base(compilation, ownerType, index, name, variance, attributes, region)
    {
      this.hasValueTypeConstraint = hasValueTypeConstraint;
      this.hasReferenceTypeConstraint = hasReferenceTypeConstraint;
      this.hasDefaultConstructorConstraint = hasDefaultConstructorConstraint;
      this.constraints = constraints ?? EmptyList<IType>.Instance;
    }
    
    public override bool HasValueTypeConstraint {
      get { return hasValueTypeConstraint; }
    }
    
    public override bool HasReferenceTypeConstraint {
      get { return hasReferenceTypeConstraint; }
    }
    
    public override bool HasDefaultConstructorConstraint {
      get { return hasDefaultConstructorConstraint; }
    }
    
    public override IEnumerable<IType> DirectBaseTypes {
      get {
        bool hasNonInterfaceConstraint = false;
        foreach (IType c in constraints) {
          yield return c;
          if (c.Kind != TypeKind.Interface)
            hasNonInterfaceConstraint = true;
        }
        // Do not add the 'System.Object' constraint if there is another constraint with a base class.
        if (this.HasValueTypeConstraint || !hasNonInterfaceConstraint) {
          yield return this.Compilation.FindType(this.HasValueTypeConstraint ? KnownTypeCode.ValueType : KnownTypeCode.Object);
        }
      }
    }
  }
  
  /*
  /// <summary>
  /// Default implementation of <see cref="ITypeParameter"/>.
  /// </summary>
  [Serializable]
  public sealed class DefaultTypeParameter : AbstractTypeParameter
  {
    IList<ITypeReference> constraints;
    
    BitVector16 flags;
    
    const ushort FlagReferenceTypeConstraint      = 0x0001;
    const ushort FlagValueTypeConstraint          = 0x0002;
    const ushort FlagDefaultConstructorConstraint = 0x0004;
    
    protected override void FreezeInternal()
    {
      constraints = FreezeList(constraints);
      base.FreezeInternal();
    }
    
    public DefaultTypeParameter(SymbolKind ownerType, int index, string name)
      : base(ownerType, index, name)
    {
    }
    
    public IList<ITypeReference> Constraints {
      get {
        if (constraints == null)
          constraints = new List<ITypeReference>();
        return constraints;
      }
    }
    
    public bool HasDefaultConstructorConstraint {
      get { return flags[FlagDefaultConstructorConstraint]; }
      set {
        CheckBeforeMutation();
        flags[FlagDefaultConstructorConstraint] = value;
      }
    }
    
    public bool HasReferenceTypeConstraint {
      get { return flags[FlagReferenceTypeConstraint]; }
      set {
        CheckBeforeMutation();
        flags[FlagReferenceTypeConstraint] = value;
      }
    }
    
    public bool HasValueTypeConstraint {
      get { return flags[FlagValueTypeConstraint]; }
      set {
        CheckBeforeMutation();
        flags[FlagValueTypeConstraint] = value;
      }
    }
    
    public override bool? IsReferenceType(ITypeResolveContext context)
    {
      switch (flags.Data & (FlagReferenceTypeConstraint | FlagValueTypeConstraint)) {
        case FlagReferenceTypeConstraint:
          return true;
        case FlagValueTypeConstraint:
          return false;
      }
      
      return base.IsReferenceTypeHelper(GetEffectiveBaseClass(context));
    }
    
    public override IType GetEffectiveBaseClass(ITypeResolveContext context)
    {
      // protect against cyclic type parameters
      using (var busyLock = BusyManager.Enter(this)) {
        if (!busyLock.Success)
          return SpecialTypes.UnknownType;
        
        if (HasValueTypeConstraint)
          return context.GetTypeDefinition("System", "ValueType", 0, StringComparer.Ordinal) ?? SpecialTypes.UnknownType;
        
        List<IType> classTypeConstraints = new List<IType>();
        foreach (ITypeReference constraintRef in this.Constraints) {
          IType constraint = constraintRef.Resolve(context);
          if (constraint.Kind == TypeKind.Class) {
            classTypeConstraints.Add(constraint);
          } else if (constraint.Kind == TypeKind.TypeParameter) {
            IType baseClass = ((ITypeParameter)constraint).GetEffectiveBaseClass(context);
            if (baseClass.Kind == TypeKind.Class)
              classTypeConstraints.Add(baseClass);
          }
        }
        if (classTypeConstraints.Count == 0)
          return KnownTypeReference.Object.Resolve(context);
        // Find the derived-most type in the resulting set:
        IType result = classTypeConstraints[0];
        for (int i = 1; i < classTypeConstraints.Count; i++) {
          if (classTypeConstraints[i].GetDefinition().IsDerivedFrom(result.GetDefinition(), context))
            result = classTypeConstraints[i];
        }
        return result;
      }
    }
    
    public override IEnumerable<IType> GetEffectiveInterfaceSet(ITypeResolveContext context)
    {
      List<IType> result = new List<IType>();
      // protect against cyclic type parameters
      using (var busyLock = BusyManager.Enter(this)) {
        if (busyLock.Success) {
          foreach (ITypeReference constraintRef in this.Constraints) {
            IType constraint = constraintRef.Resolve(context);
            if (constraint.Kind == TypeKind.Interface) {
              result.Add(constraint);
            } else if (constraint.Kind == TypeKind.TypeParameter) {
              result.AddRange(((ITypeParameter)constraint).GetEffectiveInterfaceSet(context));
            }
          }
        }
      }
      return result.Distinct();
    }
    
    public override ITypeParameterConstraints GetConstraints(ITypeResolveContext context)
    {
      return new DefaultTypeParameterConstraints(
        this.Constraints.Select(c => c.Resolve(context)),
        this.HasDefaultConstructorConstraint, this.HasReferenceTypeConstraint, this.HasValueTypeConstraint);
    }
    
    /*
   * Interning for type parameters is disabled; we can't intern cyclic structures as might
   * occur in the constraints, and incomplete interning is dangerous for type parameters
   * as we use reference equality.
    void ISupportsInterning.PrepareForInterning(IInterningProvider provider)
    {
      // protect against cyclic constraints
      using (var busyLock = BusyManager.Enter(this)) {
        if (busyLock.Success) {
          constraints = provider.InternList(constraints);
          base.PrepareForInterning(provider);
        }
      }
    }
    
    int ISupportsInterning.GetHashCodeForInterning()
    {
      unchecked {
        int hashCode = base.GetHashCodeForInterning();
        if (constraints != null)
          hashCode += constraints.GetHashCode();
        hashCode += 771 * flags.Data;
        return hashCode;
      }
    }
    
    bool ISupportsInterning.EqualsForInterning(ISupportsInterning other)
    {
      DefaultTypeParameter o = other as DefaultTypeParameter;
      return base.EqualsForInterning(o)
        && this.constraints == o.constraints
        && this.flags == o.flags;
    }
  }*/
}