public static TypeReference ReadTypeReference(XmlReader reader) { if (reader == null || reader.NodeType != XmlNodeType.Element) { return(null); } switch (reader.Name) { // For the TypeReference(s)... case "SimpleTypeReference": SimpleTypeReference simpleTypeReference = new SimpleTypeReference(); simpleTypeReference.ReadXml(reader); return(simpleTypeReference); case "SpecializedTypeReference": SpecializedTypeReference specializedTypeReference = new SpecializedTypeReference(); specializedTypeReference.ReadXml(reader); return(specializedTypeReference); case "ArrayTypeReference": ArrayTypeReference arrayTypeReference = new ArrayTypeReference(); arrayTypeReference.ReadXml(reader); return(arrayTypeReference); case "ReferenceTypeReference": ReferenceTypeReference referenceTypeReference = new ReferenceTypeReference(); referenceTypeReference.ReadXml(reader); return(referenceTypeReference); case "PointerTypeReference": PointerTypeReference pointerTypeReference = new PointerTypeReference(); pointerTypeReference.ReadXml(reader); return(pointerTypeReference); // For the TemplateTypeReference(s)... case "IndexedTemplateTypeReference": IndexedTemplateTypeReference indexedTemplateTypeReference = new IndexedTemplateTypeReference(); indexedTemplateTypeReference.ReadXml(reader); return(indexedTemplateTypeReference); case "NamedTemplateTypeReference": NamedTemplateTypeReference namedTemplateTypeReference = new NamedTemplateTypeReference(); namedTemplateTypeReference.ReadXml(reader); return(namedTemplateTypeReference); case "TypeTemplateTypeReference": TypeTemplateTypeReference typeTemplateTypeReference = new TypeTemplateTypeReference(); typeTemplateTypeReference.ReadXml(reader); return(typeTemplateTypeReference); case "MethodTemplateTypeReference": MethodTemplateTypeReference methodTemplateTypeReference = new MethodTemplateTypeReference(); methodTemplateTypeReference.ReadXml(reader); return(methodTemplateTypeReference); } return(null); }
public override IEntity VisitFieldDeclaration(FieldDeclaration fieldDeclaration, object data) { bool isSingleField = fieldDeclaration.Variables.Count() == 1; Modifiers modifiers = fieldDeclaration.Modifiers; DefaultField field = null; foreach (VariableInitializer vi in fieldDeclaration.Variables) { field = new DefaultField(currentTypeDefinition, vi.Name); field.Region = isSingleField ? MakeRegion(fieldDeclaration) : MakeRegion(vi); field.BodyRegion = MakeRegion(vi); ConvertAttributes(field.Attributes, fieldDeclaration.Attributes); ApplyModifiers(field, modifiers); field.IsVolatile = (modifiers & Modifiers.Volatile) != 0; field.IsReadOnly = (modifiers & Modifiers.Readonly) != 0; field.ReturnType = ConvertType(fieldDeclaration.ReturnType); if ((modifiers & Modifiers.Fixed) != 0) { field.ReturnType = PointerTypeReference.Create(field.ReturnType); } if ((modifiers & Modifiers.Const) != 0) { field.ConstantValue = ConvertConstantValue(field.ReturnType, vi.Initializer); } currentTypeDefinition.Fields.Add(field); } return(isSingleField ? field : null); }
public override ITypeReference ToTypeReference(NameLookupMode lookupMode = NameLookupMode.Type) { ITypeReference t = this.BaseType.ToTypeReference(lookupMode); if (this.HasNullableSpecifier) { t = NullableType.Create(t); } int pointerRank = this.PointerRank; for (int i = 0; i < pointerRank; i++) { t = new PointerTypeReference(t); } foreach (var a in this.ArraySpecifiers.Reverse()) { t = new ArrayTypeReference(t, a.Dimensions); } return(t); }
public static string GetTypeName(this PointerTypeReference obj, string[] usedNamespaces) { string retval = obj.ElementType.GetTypeName(usedNamespaces) + "*"; return(retval.NormaliseClrName(usedNamespaces)); }
static ITypeReference ParseTypeName(string typeName, ref int pos) { string reflectionTypeName = typeName; if (pos == typeName.Length) { throw new ReflectionNameParseException(pos, "Unexpected end"); } ITypeReference result; if (reflectionTypeName[pos] == '`') { // type parameter reference pos++; if (pos == reflectionTypeName.Length) { throw new ReflectionNameParseException(pos, "Unexpected end"); } if (reflectionTypeName[pos] == '`') { // method type parameter reference pos++; int index = ReflectionHelper.ReadTypeParameterCount(reflectionTypeName, ref pos); result = TypeParameterReference.Create(SymbolKind.Method, index); } else { // class type parameter reference int index = ReflectionHelper.ReadTypeParameterCount(reflectionTypeName, ref pos); result = TypeParameterReference.Create(SymbolKind.TypeDefinition, index); } } else { // not a type parameter reference: read the actual type name List <ITypeReference> typeArguments = new List <ITypeReference>(); int typeParameterCount; string typeNameWithoutSuffix = ReadTypeName(typeName, ref pos, true, out typeParameterCount, typeArguments); result = new GetPotentiallyNestedClassTypeReference(typeNameWithoutSuffix, typeParameterCount); while (pos < typeName.Length && typeName[pos] == '.') { pos++; string nestedTypeName = ReadTypeName(typeName, ref pos, false, out typeParameterCount, typeArguments); result = new NestedTypeReference(result, nestedTypeName, typeParameterCount); } if (typeArguments.Count > 0) { result = new ParameterizedTypeReference(result, typeArguments); } } while (pos < typeName.Length) { switch (typeName[pos]) { case '[': int dimensions = 1; do { pos++; if (pos == typeName.Length) { throw new ReflectionNameParseException(pos, "Unexpected end"); } if (typeName[pos] == ',') { dimensions++; } } while (typeName[pos] != ']'); result = new ArrayTypeReference(result, dimensions); break; case '*': result = new PointerTypeReference(result); break; case '@': result = new ByReferenceTypeReference(result); break; default: return(result); } pos++; } return(result); }
public AstType ConvertTypeReference(ITypeReference typeRef) { ArrayTypeReference array = typeRef as ArrayTypeReference; if (array != null) { return(ConvertTypeReference(array.ElementType).MakeArrayType(array.Dimensions)); } PointerTypeReference pointer = typeRef as PointerTypeReference; if (pointer != null) { return(ConvertTypeReference(pointer.ElementType).MakePointerType()); } ByReferenceType brt = typeRef as ByReferenceType; if (brt != null) { return(ConvertTypeReference(brt.ElementType)); } IType type = typeRef.Resolve(context); if (type.Kind != TypeKind.Unknown) { return(ConvertType(type)); } // Unknown type, let's try if we can find an appropriate type // (anything is better than displaying a question mark) KnownTypeReference knownType = typeRef as KnownTypeReference; if (knownType != null) { string keyword = ReflectionHelper.GetCSharpNameByTypeCode(knownType.TypeCode); if (keyword != null) { return(new PrimitiveType(keyword)); } } SimpleTypeOrNamespaceReference str = typeRef as SimpleTypeOrNamespaceReference; if (str != null) { return(new SimpleType(str.Identifier, str.TypeArguments.Select(ConvertTypeReference))); } MemberTypeOrNamespaceReference mtr = typeRef as MemberTypeOrNamespaceReference; if (mtr != null) { return(new MemberType(ConvertTypeReference(mtr.Target), mtr.Identifier, mtr.TypeArguments.Select(ConvertTypeReference)) { IsDoubleColon = mtr.Target is AliasNamespaceReference }); } AliasNamespaceReference alias = typeRef as AliasNamespaceReference; if (alias != null) { return(new SimpleType(alias.Identifier)); } // Unknown type reference that couldn't be resolved return(new SimpleType("?")); }
static void AppendTypeName(StringBuilder b, ITypeReference type, ITypeResolveContext context) { IType resolvedType = type as IType; if (resolvedType != null) { AppendTypeName(b, resolvedType); return; } GetClassTypeReference gctr = type as GetClassTypeReference; if (gctr != null) { if (!string.IsNullOrEmpty(gctr.Namespace)) { b.Append(gctr.Namespace); b.Append('.'); } b.Append(gctr.Name); if (gctr.TypeParameterCount > 0) { b.Append('`'); b.Append(gctr.TypeParameterCount); } return; } NestedTypeReference ntr = type as NestedTypeReference; if (ntr != null) { AppendTypeName(b, ntr.DeclaringTypeReference, context); b.Append('.'); b.Append(ntr.Name); if (ntr.AdditionalTypeParameterCount > 0) { b.Append('`'); b.Append(ntr.AdditionalTypeParameterCount); } return; } ParameterizedTypeReference pt = type as ParameterizedTypeReference; if (pt != null && IsGetClassTypeReference(pt.GenericType)) { AppendParameterizedTypeName(b, pt.GenericType, pt.TypeArguments, context); return; } ArrayTypeReference array = type as ArrayTypeReference; if (array != null) { AppendTypeName(b, array.ElementType, context); b.Append('['); if (array.Dimensions > 1) { for (int i = 0; i < array.Dimensions; i++) { if (i > 0) { b.Append(','); } b.Append("0:"); } } b.Append(']'); return; } PointerTypeReference ptr = type as PointerTypeReference; if (ptr != null) { AppendTypeName(b, ptr.ElementType, context); b.Append('*'); return; } ByReferenceTypeReference brtr = type as ByReferenceTypeReference; if (brtr != null) { AppendTypeName(b, brtr.ElementType, context); b.Append('@'); return; } if (context == null) { b.Append('?'); } else { AppendTypeName(b, type.Resolve(context)); } }
public void VisitPointerTypeReference(PointerTypeReference typeReference) { Formatter.StartNode(typeReference); typeReference.BaseType.AcceptVisitor(this); Formatter.WriteToken("*"); Formatter.EndNode(); }
private void WritePointerType(PointerTypeReference pointer, ReferenceLinkDisplayOptions options, XmlWriter writer, IDictionary <IndexedTemplateTypeReference, TypeReference> dictionary) { WriteType(pointer.PointedToType, options, writer, dictionary); writer.WriteString("*"); }
public ImmutableNode <string> Visit(PointerTypeReference pointerTypeReference) { return(new ImmutableNode <string>(pointerTypeReference.ElementType.Accept(this), "*", null)); }
internal static ITypeReference ConvertType(AstType type, ITypeDefinition parentTypeDefinition, IMethod parentMethodDefinition, UsingScope parentUsingScope, bool isInUsingDeclaration) { SimpleType s = type as SimpleType; if (s != null) { List <ITypeReference> typeArguments = new List <ITypeReference>(); foreach (var ta in s.TypeArguments) { typeArguments.Add(ConvertType(ta, parentTypeDefinition, parentMethodDefinition, parentUsingScope, isInUsingDeclaration)); } if (typeArguments.Count == 0 && parentMethodDefinition != null) { // SimpleTypeOrNamespaceReference doesn't support method type parameters, // so we directly handle them here. foreach (ITypeParameter tp in parentMethodDefinition.TypeParameters) { if (tp.Name == s.Identifier) { return(tp); } } } return(new SimpleTypeOrNamespaceReference(s.Identifier, typeArguments, parentTypeDefinition, parentUsingScope, isInUsingDeclaration)); } PrimitiveType p = type as PrimitiveType; if (p != null) { switch (p.Keyword) { case "string": return(KnownTypeReference.String); case "int": return(KnownTypeReference.Int32); case "uint": return(KnownTypeReference.UInt32); case "object": return(KnownTypeReference.Object); case "bool": return(KnownTypeReference.Boolean); case "sbyte": return(KnownTypeReference.SByte); case "byte": return(KnownTypeReference.Byte); case "short": return(KnownTypeReference.Int16); case "ushort": return(KnownTypeReference.UInt16); case "long": return(KnownTypeReference.Int64); case "ulong": return(KnownTypeReference.UInt64); case "float": return(KnownTypeReference.Single); case "double": return(KnownTypeReference.Double); case "decimal": return(ReflectionHelper.ToTypeReference(TypeCode.Decimal)); case "char": return(KnownTypeReference.Char); case "void": return(KnownTypeReference.Void); default: return(SharedTypes.UnknownType); } } MemberType m = type as MemberType; if (m != null) { ITypeOrNamespaceReference t; if (m.IsDoubleColon) { SimpleType st = m.Target as SimpleType; if (st != null) { t = new AliasNamespaceReference(st.Identifier, parentUsingScope); } else { t = null; } } else { t = ConvertType(m.Target, parentTypeDefinition, parentMethodDefinition, parentUsingScope, isInUsingDeclaration) as ITypeOrNamespaceReference; } if (t == null) { return(SharedTypes.UnknownType); } List <ITypeReference> typeArguments = new List <ITypeReference>(); foreach (var ta in m.TypeArguments) { typeArguments.Add(ConvertType(ta, parentTypeDefinition, parentMethodDefinition, parentUsingScope, isInUsingDeclaration)); } return(new MemberTypeOrNamespaceReference(t, m.MemberName, typeArguments, parentTypeDefinition, parentUsingScope)); } ComposedType c = type as ComposedType; if (c != null) { ITypeReference t = ConvertType(c.BaseType, parentTypeDefinition, parentMethodDefinition, parentUsingScope, isInUsingDeclaration); if (c.HasNullableSpecifier) { t = NullableType.Create(t); } for (int i = 0; i < c.PointerRank; i++) { t = PointerTypeReference.Create(t); } foreach (var a in c.ArraySpecifiers.Reverse()) { t = ArrayTypeReference.Create(t, a.Dimensions); } return(t); } Debug.WriteLine("Unknown node used as type: " + type); return(SharedTypes.UnknownType); }
public void PointerType() { var type = new PointerTypeReference(new PrimitiveTypeReference(PrimitiveType.Byte)); var result = type.Resolve(_compilationUnit.GetScope()); Assert.IsInstanceOfType(result, typeof(MemberResolveResult)); Assert.IsInstanceOfType(result.ScopeProvider, typeof(PointerTypeDefinition)); var pointerType = (PointerTypeDefinition)result.ScopeProvider; Assert.AreEqual("System.Byte", pointerType.BaseType.FullName); }
public InheritanceViaGenericAdapter(TranslatedLibrary library, Adapter targetAdapter, Adapter replacedAdapter) : base(targetAdapter) { // Save and validate our output type // (We mostly only validate the replaced adapter since we assume it's well-formed to adapt to this output.) OutputType = targetAdapter.InputType; if (OutputType is not PointerTypeReference) { throw new ArgumentException("The target adapter must take a pointer.", nameof(targetAdapter)); } // Determine the actual record type TypeReference recordTypeReference = replacedAdapter.InputType; if (recordTypeReference is ByRefTypeReference byRefType) { ByRefKind = byRefType.Kind; recordTypeReference = byRefType.Inner; } int pointerArity = 0; while (recordTypeReference is PointerTypeReference pointerType) { pointerArity++; recordTypeReference = pointerType.Inner; } if (ByRefKind is null && pointerArity == 0) { throw new ArgumentException("The replaced adapter must be passed by reference.", nameof(replacedAdapter)); } if (recordTypeReference is not TranslatedTypeReference translatedType) { throw new ArgumentException("The replaced adapter does not adapt a translated type reference or uses an unrecognized method to do so.", nameof(replacedAdapter)); } if (translatedType.TryResolve(library) is not TranslatedRecord targetRecord) { throw new ArgumentException("The replaced adapter does not adapt a record type reference.", nameof(replacedAdapter)); } // Determine the constraint info ConstraintInterfaceNamespace = $"{targetRecord.Namespace}.{PhysXMarkerInterfacesDeclaration.InfrastructureNamespaceName}"; ConstraintInterfaceTypeName = $"I{targetRecord.Name}"; // Name the generic parameter based on the parameter name GenericParameterName = $"T{Char.ToUpperInvariant(replacedAdapter.Name[0])}{replacedAdapter.Name.AsSpan().Slice(1)}"; // Name our temporary (only used when we're byref) TemporaryName = $"__{Name}P"; // Create the input type InputType = new ExternallyDefinedTypeReference(GenericParameterName); for (int i = 0; i < pointerArity; i++) { InputType = new PointerTypeReference(InputType); } TemporaryType = InputType; if (ByRefKind is ByRefKind byRefKind) { InputType = new ByRefTypeReference(byRefKind, InputType); TemporaryType = new PointerTypeReference(TemporaryType); } }