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); }