TupleTypeSpec ParseTuple()
{
TupleTypeSpec tuple = new TupleTypeSpec();
ConsumeList(tuple.Elements, TypeTokenKind.RightParenthesis, "tuple");
return(tuple);
}
protected override bool LLEquals(TypeSpec other, bool partialNameMatch)
{
TupleTypeSpec spec = other as TupleTypeSpec;
if (spec == null)
{
return(false);
}
return(ListEqual(Elements, spec.Elements, partialNameMatch));
}
static bool ReplaceName(TupleTypeSpec tuple, string toFind, string replacement, ref TypeSpec result)
{
List <TypeSpec> resultTypes = new List <TypeSpec> (tuple.Elements.Count);
if (ReplaceName(tuple.Elements, toFind, replacement, resultTypes))
{
result = new TupleTypeSpec(resultTypes);
return(true);
}
result = tuple;
return(false);
}
public TupleTypeSpec(TupleTypeSpec other)
: base(TypeSpecKind.Tuple)
{
Elements = new List <TypeSpec> ();
Elements.AddRange(other.Elements);
if (other.HasAttributes)
{
Attributes.AddRange(other.Attributes);
}
if (other.ContainsGenericParameters)
{
GenericParameters.AddRange(other.GenericParameters);
}
IsInOut = other.IsInOut;
}
public bool IsBoundGeneric(BaseDeclaration context, TypeMapper mapper)
{
switch (this.Kind)
{
case TypeSpecKind.Named:
NamedTypeSpec ns = (NamedTypeSpec)this;
Entity en = mapper.TryGetEntityForSwiftClassName(ns.Name);
if (en == null)
{
if (context.IsTypeSpecGeneric(ns))
{
return(false); // unbound
}
}
foreach (TypeSpec genParm in GenericParameters)
{
if (genParm.IsUnboundGeneric(context, mapper))
{
return(false); // unbound
}
}
return(true);
case TypeSpecKind.Closure:
ClosureTypeSpec cs = (ClosureTypeSpec)this;
return(cs.Arguments.IsBoundGeneric(context, mapper) && cs.ReturnType.IsBoundGeneric(context, mapper));
case TypeSpecKind.Tuple:
TupleTypeSpec ts = (TupleTypeSpec)this;
foreach (TypeSpec elem in ts.Elements)
{
if (elem.IsUnboundGeneric(context, mapper))
{
return(false);
}
}
return(true);
default:
throw new NotSupportedException("unknown TypeSpecKind " + this.Kind.ToString());
}
}
public IEnumerable <TypeSpec> EachArgument()
{
if (!HasArguments())
{
yield break;
}
TupleTypeSpec argList = Arguments as TupleTypeSpec;
if (argList != null)
{
foreach (TypeSpec arg in argList.Elements)
{
yield return(arg);
}
}
else
{
yield return(Arguments);
}
}
public bool IsUnboundGeneric(BaseDeclaration context, TypeMapper mapper)
{
switch (Kind)
{
case TypeSpecKind.Named:
NamedTypeSpec ns = (NamedTypeSpec)this;
if (context.IsTypeSpecGeneric(ns.ToString()))
{
return(true);
}
foreach (TypeSpec genparm in GenericParameters)
{
if (genparm.IsUnboundGeneric(context, mapper))
{
return(true);
}
}
return(false);
case TypeSpecKind.Closure:
ClosureTypeSpec cs = (ClosureTypeSpec)this;
return(cs.Arguments.IsUnboundGeneric(context, mapper) && cs.ReturnType.IsUnboundGeneric(context, mapper));
case TypeSpecKind.Tuple:
TupleTypeSpec ts = (TupleTypeSpec)this;
foreach (TypeSpec elem in ts.Elements)
{
if (elem.IsUnboundGeneric(context, mapper))
{
return(true);
}
}
return(false);
case TypeSpecKind.ProtocolList:
return(false);
default:
throw new NotSupportedException("unknown TypeSpecKind " + this.Kind.ToString());
}
}
TypeSpec Parse()
{
TypeSpecToken token = tokenizer.Peek();
TypeSpec type = null;
List <TypeSpecAttribute> attrs = null;
var inout = false;
string typeLabel = null;
// Prefix
// parse any attributes
if (token.Kind == TypeTokenKind.At)
{
attrs = ParseAttributes();
token = tokenizer.Peek();
}
// looks like it's inout
if (token.Kind == TypeTokenKind.TypeName && token.Value == "inout")
{
inout = true;
tokenizer.Next();
token = tokenizer.Peek();
}
if (token.Kind == TypeTokenKind.TypeLabel)
{
typeLabel = token.Value;
tokenizer.Next();
token = tokenizer.Peek();
}
// meat
if (token.Kind == TypeTokenKind.LeftParenthesis) // tuple
{
tokenizer.Next();
TupleTypeSpec tuple = ParseTuple();
type = tuple.Elements.Count == 1 ? tuple.Elements [0] : tuple;
typeLabel = type.TypeLabel;
}
else if (token.Kind == TypeTokenKind.TypeName) // name
{
tokenizer.Next();
var tokenValue = token.Value.StartsWith("ObjectiveC.", StringComparison.Ordinal) ?
"Foundation" + token.Value.Substring("ObjectiveC".Length) : token.Value;
type = new NamedTypeSpec(tokenValue);
}
else if (token.Kind == TypeTokenKind.LeftBracket) // array
{
tokenizer.Next();
type = ParseArray();
}
else // illegal
{
throw ErrorHelper.CreateError(ReflectorError.kTypeParseBase + 0, $"Unexpected token {token.Value}.");
}
// look-ahead for closure
if (tokenizer.Peek().Kind == TypeTokenKind.TypeName && tokenizer.Peek().Value == "throws")
{
tokenizer.Next();
if (tokenizer.Peek().Kind != TypeTokenKind.Arrow)
{
throw ErrorHelper.CreateError(ReflectorError.kTypeParseBase + 1, $"Unexpected token {tokenizer.Peek ().Value} after a 'throws' in a closure.");
}
tokenizer.Next();
type = ParseClosure(type, true);
}
if (tokenizer.Peek().Kind == TypeTokenKind.Arrow)
{
tokenizer.Next();
type = ParseClosure(type, false);
}
else if (tokenizer.Peek().Kind == TypeTokenKind.LeftAngle)
{
tokenizer.Next();
type = Genericize(type);
}
if (tokenizer.Peek().Kind == TypeTokenKind.Period)
{
tokenizer.Next();
var currType = type as NamedTypeSpec;
if (currType == null)
{
throw ErrorHelper.CreateError(ReflectorError.kTypeParseBase + 2, $"In parsing an inner type (type.type), first element is a {type.Kind} instead of a NamedTypeSpec.");
}
var nextType = Parse() as NamedTypeSpec;
if (nextType == null)
{
throw ErrorHelper.CreateError(ReflectorError.kTypeParseBase + 3, $"In parsing an inner type (type.type), the second element is a {nextType.Kind} instead of a NamedTypeSpec");
}
currType.InnerType = nextType;
}
// Postfix
if (tokenizer.Peek().Kind == TypeTokenKind.Ampersand)
{
type = ParseProtocolList(type as NamedTypeSpec);
}
while (tokenizer.Peek().Kind == TypeTokenKind.QuestionMark)
{
tokenizer.Next();
type = WrapAsBoundGeneric(type, "Swift.Optional");
}
if (tokenizer.Peek().Kind == TypeTokenKind.ExclamationPoint)
{
tokenizer.Next();
type = WrapAsBoundGeneric(type, "Swift.ImplicitlyUnwrappedOptional");
}
type.IsInOut = inout;
type.TypeLabel = typeLabel;
if (type != null && attrs != null)
{
type.Attributes.AddRange(attrs);
}
return(type);
}
