internal override void WriteIdentity(StringBuilder builder)
{
builder.Append("Property(");
if (UnresolvedType != null && !UnresolvedType.Trim().Equals(String.Empty))
{
if (_collectionKind != CollectionKind.None)
{
builder.Append("Collection(" + UnresolvedType + ")");
}
else if (_isRefType)
{
builder.Append("Ref(" + UnresolvedType + ")");
}
else
{
builder.Append(UnresolvedType);
}
}
else
{
_typeSubElement.WriteIdentity(builder);
}
builder.Append(")");
}
public bool TryGetType(UnresolvedType unresolved, out Type type)
{
var names = unresolved.Name.Split('.');
var @namespace = string.Concat(names.Take(names.Length - 1));
if (!string.IsNullOrEmpty(@namespace))
{
if (namespaces.TryGetValue(@namespace, out Type[] types)) //alias
public static IParsingResult Parse(ParsingContext context)
{
IParsingResult name = UnresolvedType.Parse(context) ?? SimpleId.Parse(context);
if (name != null)
{
return(new DestructorName(name));
}
return(null);
}
internal void UpdateResolvedType(UnresolvedType t, TypeNameTokens typeName)
{
if (typeName != null && !_identifiedTypes.ContainsKey(typeName.completeTypeName))
{
_identifiedTypes[typeName.completeTypeName] = Type.GetType(typeName.completeTypeName);
}
else if (t.resolvedTypeName != null && typeName == null)
{
_identifiedTypes.Remove(t.resolvedTypeName.completeTypeName);
}
t.resolvedTypeName = typeName;
}
internal override void WriteIdentity(StringBuilder builder)
{
if (UnresolvedType != null && !UnresolvedType.Trim().Equals(String.Empty))
{
builder.Append("Collection(" + UnresolvedType + ")");
}
else
{
builder.Append("Collection(");
_typeSubElement.WriteIdentity(builder);
builder.Append(")");
}
}
/// <inheritdoc/>
protected override IUserType Bind(UserTypeContext node, ISymbol parent)
{
var type = parent.ResolveType(node.IDENTIFIER().Symbol.Text);
if (type == null)
{
type = new UnresolvedType(node, parent, node.IDENTIFIER().Symbol.Text);
}
return(new UserTypeBuilder()
.SetNode(node)
.SetParent(parent)
.SetDefinition(type)
.Build());
}
internal override void WriteIdentity(StringBuilder builder)
{
Debug.Assert(UnresolvedType != null && UnresolvedType.Trim().Length != 0);
builder.Append("Ref(" + UnresolvedType + ")");
}
internal override void WriteIdentity(StringBuilder builder)
{
Debug.Assert(UnresolvedType != null && !UnresolvedType.Trim().Equals(String.Empty));
builder.Append("Ref(" + UnresolvedType + ")");
}
public virtual T Visit(UnresolvedType node)
{
return(Visit((TypeNode)node));
}
public override bool Equals(object o)
{
UnresolvedType other = o as UnresolvedType;
return(other != null && adapter.Equals(other.adapter));
}
public override bool Visit(UnresolvedType node)
{
Visit((TypeNode)node);
return(true);
}
public void unresolvedTypeSubtypeIndication(UnresolvedType subtype)
{
writer.AppendIdentifier(subtype);
}
public void visit(UnresolvedType item)
{
return;
}
protected Type TypeFromDecl(Declaration decl)
{
var unresolved = new UnresolvedType(decl.Type);
return(decl != null?TypeFromDeclarator(decl.Declarator, unresolved) : unresolved);
}
private DataType resolve_type(UnresolvedType unresolved_type)
{
DataType type = null;
// still required for vapigen
if (unresolved_type.unresolved_symbol.name == "void")
{
return(new VoidType());
}
var sym = resolve_symbol(unresolved_type.unresolved_symbol);
if (sym == null)
{
// don't report same error twice
if (!unresolved_type.unresolved_symbol.error)
{
Report.error(unresolved_type.source_reference, "The type name `%s' could not be found".printf(unresolved_type.unresolved_symbol.ToString()));
}
return(new InvalidType());
}
if (sym is TypeParameter)
{
type = new GenericType((TypeParameter)sym);
}
else if (sym is TypeSymbol)
{
if (sym is ValaDelegate)
{
type = new DelegateType((ValaDelegate)sym);
}
else if (sym is Class)
{
var cl = (Class)sym;
if (cl.is_error_base)
{
type = new ErrorType(null, null, unresolved_type.source_reference);
}
else
{
type = new ObjectType(cl);
}
}
else if (sym is Interface)
{
type = new ObjectType((Interface)sym);
}
else if (sym is Struct)
{
type = get_type_for_struct((Struct)sym, (Struct)sym);
}
else if (sym is ValaEnum)
{
type = new EnumValueType((ValaEnum)sym);
}
else if (sym is ErrorDomain)
{
type = new ErrorType((ErrorDomain)sym, null, unresolved_type.source_reference);
}
else if (sym is ErrorCode)
{
type = new ErrorType((ErrorDomain)sym.parent_symbol, (ErrorCode)sym, unresolved_type.source_reference);
}
else
{
Report.error(unresolved_type.source_reference, "internal error: `%s' is not a supported type".printf(sym.get_full_name()));
return(new InvalidType());
}
}
else
{
Report.error(unresolved_type.source_reference, "`%s' is not a type".printf(sym.get_full_name()));
return(new InvalidType());
}
type.source_reference = unresolved_type.source_reference;
type.value_owned = unresolved_type.value_owned;
sym.used = true;
if (type is GenericType)
{
// type parameters are always considered nullable
// actual type argument may or may not be nullable
type.nullable = true;
}
else
{
type.nullable = unresolved_type.nullable;
}
type.is_dynamic = unresolved_type.is_dynamic;
foreach (DataType type_arg in unresolved_type.get_type_arguments())
{
type.add_type_argument(type_arg);
}
return(type);
}
