public SwiftType RenamedCloneOf(SwiftName newName)
        {
            var ty = MemberwiseClone() as SwiftType;

            ty.Name = newName;
            return(ty);
        }
        public void SwiftNamePunyNotEquals()
        {
            SwiftName sn  = new SwiftName("GrIh", true);
            SwiftName sn1 = new SwiftName("Bob1", false);

            Assert.AreNotEqual(sn, sn1);
        }
        public void SwiftNamePunyEquals()
        {
            SwiftName sn  = new SwiftName("GrIh", true);
            SwiftName sn1 = new SwiftName("GrIh", true);

            Assert.AreEqual(sn, sn1);
        }
        public void SwiftNameNotEquals()
        {
            SwiftName sn  = new SwiftName("Bob", false);
            SwiftName sn1 = new SwiftName("Bob1", false);

            Assert.AreNotEqual(sn, sn1);
        }
Example #5
0
 public SwiftClassName(SwiftName module, IList <MemberNesting> nesting, IList <SwiftName> nestingNames, OperatorType oper = OperatorType.None)
 {
     Module       = Ex.ThrowOnNull(module, "module");
     Nesting      = Ex.ThrowOnNull(nesting, "nesting");
     NestingNames = Ex.ThrowOnNull(nestingNames, "nestingNames");
     Terminus     = NestingNames.Count > 0 ? NestingNames [NestingNames.Count - 1] : null;
     Operator     = oper;
 }
 protected SwiftType(CoreCompoundType type, bool isReference, SwiftName name = null)
 {
     Type        = type;
     IsReference = isReference;
     Name        = name;
     Attributes  = new List <SwiftTypeAttribute> ();
     IsVariadic  = false;
 }
 public SwiftTupleType(IEnumerable <SwiftType> contents, bool isReference, SwiftName name = null)
     : base(CoreCompoundType.Tuple, isReference, name)
 {
     Contents = new List <SwiftType> ();
     if (contents != null)
     {
         Contents.AddRange(contents);
     }
 }
 public SwiftPropertyType(SwiftType unCurriedParameter, PropertyType propType, SwiftName propName,
                          SwiftName privateName, SwiftFunctionType accessor, bool isStatic, bool isReference, SwiftType extensionOn = null)
     : base(unCurriedParameter, accessor.Parameters, accessor.ReturnType, isReference, false, propName, extensionOn)
 {
     PropertyType = propType;
     PrivateName  = privateName;
     OfType       = accessor;
     IsSubscript  = true;
     IsStatic     = isStatic;
 }
 public SwiftProtocolListType(SwiftClassType protocol, bool isReference, SwiftName name = null)
     : base(CoreCompoundType.ProtocolList, isReference, name)
 {
     Protocols = new List <SwiftClassType> ();
     if (!protocol.IsProtocol)
     {
         throw new ArgumentOutOfRangeException($"Type {protocol.ClassName.ToFullyQualifiedName ()} is not a protocol");
     }
     Protocols.Add(protocol);
 }
        public SwiftName Map(SwiftName sn)
        {
            SwiftName mapped = Ex.ThrowOnNull(sn, nameof(sn));

            if (map.TryGetValue(sn, out mapped))
            {
                return(mapped);
            }
            return(sn);
        }
 public SwiftGenericArgReferenceType(int depth, int index, bool isReference, SwiftName name = null, List <string> associatedTypePath = null)
     : base(CoreCompoundType.GenericReference, isReference, name)
 {
     Depth = depth;
     Index = index;
     AssociatedTypePath = new List <string> ();
     if (associatedTypePath != null)
     {
         AssociatedTypePath.AddRange(associatedTypePath);
     }
 }
 public SwiftPropertyType(SwiftType unCurriedParameter, PropertyType propType, SwiftName propName,
                          SwiftName privateName, SwiftType ofType, bool isStatic, bool isReference, SwiftType extensionOn = null)
     : base(unCurriedParameter,
            (propType == PropertyType.Setter || propType == PropertyType.Materializer) ? ofType : SwiftTupleType.Empty,
            (propType == PropertyType.Getter) ? ofType : SwiftTupleType.Empty,
            isReference, false, propName, extensionOn)
 {
     PropertyType = propType;
     PrivateName  = privateName;
     OfType       = Ex.ThrowOnNull(ofType, "ofType");
     IsSubscript  = false;
     IsStatic     = isStatic;
 }
Example #13
0
        public static SwiftClassName FromFullyQualifiedName(string fullyQualifiedName, OperatorType oper, params char [] nesting)
        {
            string [] parts = Ex.ThrowOnNull(fullyQualifiedName, "fullyQualifiedName").Split('.');
            if (parts.Length < 2)
            {
                throw new ArgumentException(String.Format("Fully qualified name '{0}' requires at least a module and one name.",
                                                          fullyQualifiedName));
            }
            if (nesting.Length != parts.Length - 1)
            {
                throw new ArgumentException(String.Format("Nesting should have {0} elements, but has {1}.",
                                                          parts.Length - 1, nesting.Length), "nesting");
            }
            SwiftName            module        = new SwiftName(parts [0], false);
            List <SwiftName>     nestingNames  = parts.Skip(1).Select(name => new SwiftName(name, false)).ToList();
            List <MemberNesting> actualNesting = nesting.Select(c => Decomposer.ToMaybeMemberNesting(c, true).Value).ToList();

            return(new SwiftClassName(module, actualNesting, nestingNames, oper));
        }
 public SwiftMetaClassType(SwiftClassType classType, bool isReference, SwiftName name = null)
     : base(CoreCompoundType.MetaClass, isReference, name)
 {
     Class = Ex.ThrowOnNull(classType, nameof(classType));
 }
 public SwiftExistentialMetaType(SwiftProtocolListType protocolList, bool isReference, SwiftName name = null)
     : base(CoreCompoundType.MetaClass, isReference, name)
 {
     Protocol = Ex.ThrowOnNull(protocolList, nameof(protocolList));
 }
 public SwiftProtocolListType(IEnumerable <SwiftClassType> protocols, bool isReference, SwiftName name = null)
     : base(CoreCompoundType.ProtocolList, isReference, name)
 {
     Protocols = new List <SwiftClassType> ();
     Protocols.AddRange(protocols.Where(p => {
         if (p.IsProtocol)
         {
             return(true);
         }
         else
         {
             throw new ArgumentOutOfRangeException("protocols", "protocols must contain only SwiftClassType with EntityKind protocol.");
         }
     }));
 }
 public SwiftBaseFunctionType(SwiftType parms, SwiftType ret, bool isReference, bool canThrow, SwiftName name = null, SwiftType extensionOn = null)
     : base(CoreCompoundType.Function, isReference, name)
 {
     Parameters       = Ex.ThrowOnNull(parms, nameof(parms));
     ReturnType       = Ex.ThrowOnNull(ret, nameof(ret));
     GenericArguments = new List <GenericArgument> ();
     CanThrow         = canThrow;
     ExtensionOn      = extensionOn;
 }
 public SwiftArrayType(bool isReference, SwiftName name = null)
     : base(CoreCompoundType.Array, isReference, name)
 {
 }
 public SwiftClassType(SwiftClassName className, bool isReference, SwiftName name = null)
     : base(CoreCompoundType.Class, isReference, name)
 {
     ClassName = className;
 }
 public SwiftTupleType(bool isReference, SwiftName name, params SwiftType [] contents)
     : this(contents, isReference, name)
 {
 }
 public SwiftUncurriedFunctionType(SwiftType unCurriedParameter,
                                   SwiftType parms, SwiftType ret, bool isReference, bool canThrow, SwiftName name = null, SwiftType extensionOn = null)
     : this(MemberType.UncurriedFunction, unCurriedParameter, parms, ret, isReference, canThrow, name, extensionOn)
 {
 }
 public SwiftAddressorType(AddressorType addressor, SwiftType ret, bool isReference, SwiftName name = null)
     : base(SwiftTupleType.Empty, ret, isReference, false, name, null)
 {
     AddressorType = addressor;
 }
 public SwiftCFunctionType(SwiftType parms, SwiftType ret, bool isReference, SwiftName name = null)
     : base(parms, ret, isReference, false, name, null)
 {
 }
 public SwiftInitializerType(InitializerType initType, SwiftType ret, SwiftClassType owner, SwiftName name)
     : base(SwiftTupleType.Empty, ret, false, false, name, null)
 {
     Owner           = Ex.ThrowOnNull(owner, nameof(owner));
     InitializerType = initType;
 }
 public SwiftFunctionType(SwiftType parms, SwiftType ret, bool isReference, bool canThrow, SwiftName name = null, SwiftType extensionOn = null, bool isEscaping = true)
     : base(parms, ret, isReference, canThrow, name, extensionOn)
 {
     IsEscaping = isEscaping;
 }
 public SwiftCFunctionPointerType(SwiftType parms, SwiftType ret, bool isReference, bool canThrow, SwiftName name = null)
     : base(parms, ret, isReference, canThrow, name, null)
 {
 }
 public SwiftModuleNameType(SwiftName name, bool isReference)
     : base(CoreCompoundType.ModuleName, isReference, name)
 {
 }
 public SwiftBuiltInType(CoreBuiltInType scalarType, bool isReference, SwiftName name = null)
     : base(CoreCompoundType.Scalar, isReference, name)
 {
     BuiltInType = scalarType;
 }
 protected SwiftUncurriedFunctionType(MemberType memberType, SwiftType unCurriedParameter, SwiftType parms, SwiftType ret, bool isReference, bool canThrow, SwiftName name = null, SwiftType extensionOn = null)
     : base(parms, ret, isReference, canThrow, name, extensionOn)
 {
     // oddly enough, this is allowed to be null
     UncurriedParameter = unCurriedParameter;
     this.memberType    = memberType;
 }
 public SwiftStaticFunctionType(SwiftType parms, SwiftType ret, bool isReference, bool canThrow, SwiftClassType ofClass, SwiftName name = null, SwiftType extensionOn = null)
     : base(parms, ret, isReference, canThrow, name, extensionOn)
 {
     OfClass = ofClass;
 }