private void WriteMethodModifiers(IMethodDefinition method) { if (method.IsMethodUnsafe() || (method.IsConstructor && IsBaseConstructorCallUnsafe(method.ContainingTypeDefinition))) { WriteKeyword("unsafe"); } if (method.IsStatic) { WriteKeyword("static"); } if (method.IsPlatformInvoke) { WriteKeyword("extern"); } if (method.IsVirtual) { if (method.ContainingTypeDefinition.IsInterface) { if (method.IsStatic && method.IsAbstract) { WriteKeyword("abstract"); } } else if (method.IsNewSlot) { if (method.IsAbstract) { WriteKeyword("abstract"); } else if (!method.IsSealed) // non-virtual interfaces implementations are sealed virtual newslots { WriteKeyword("virtual"); } } else { if (method.IsAbstract) { WriteKeyword("abstract"); } else if (method.IsSealed) { WriteKeyword("sealed"); } WriteKeyword("override"); } } }
private void WriteMethodDefinition(IMethodDefinition method) { if (method.IsPropertyOrEventAccessor()) { return; } WriteMethodPseudoCustomAttributes(method); WriteAttributes(method.Attributes); WriteAttributes(method.SecurityAttributes); WriteAttributes(method.ReturnValueAttributes, prefix: "return"); if (method.IsDestructor()) { // If platformNotSupportedExceptionMessage is != null we're generating a dummy assembly which means we don't need a destructor at all. if (_platformNotSupportedExceptionMessage == null) { WriteDestructor(method); } return; } if (method.ContainingTypeDefinition.IsInterface) { if (method.IsMethodUnsafe()) { WriteKeyword("unsafe"); } } else { if (!method.IsExplicitInterfaceMethod() && !method.IsStaticConstructor) { WriteVisibility(method.Visibility); } WriteMethodModifiers(method); } WriteInterfaceMethodModifiers(method); WriteMethodDefinitionSignature(method); WriteMethodBody(method); }
private void WriteMethodModifiers(IMethodDefinition method) { if (method.IsMethodUnsafe()) { WriteKeyword("unsafe"); } if (method.IsStatic) { WriteKeyword("static"); } if (method.IsVirtual) { if (method.IsNewSlot) { if (method.IsAbstract) { WriteKeyword("abstract"); } else if (!method.IsSealed) // non-virtual interfaces implementations are sealed virtual newslots { WriteKeyword("virtual"); } } else { if (method.IsAbstract) { WriteKeyword("abstract"); } else if (method.IsSealed) { WriteKeyword("sealed"); } WriteKeyword("override"); } } }
public void WriteTypeDeclaration(ITypeDefinition type) { INamedTypeDefinition namedType = (INamedTypeDefinition)type; WriteAttributes(type.Attributes); WriteAttributes(type.SecurityAttributes); //TODO: We should likely add support for the SerializableAttribute something like: // if (type.IsSerializable) WriteFakeAttribute("System.Serializable"); // But we need also consider if this attribute is filtered out or not but I guess // we have the same problem with all the fake attributes at this point. if ((type.IsStruct || type.IsClass) && type.Layout != LayoutKind.Auto) { FakeCustomAttribute structLayout = new FakeCustomAttribute("System.Runtime.InteropServices", "StructLayoutAttribute"); string layoutKind = string.Format("System.Runtime.InteropServices.LayoutKind.{0}", type.Layout.ToString()); if (_forCompilationIncludeGlobalprefix) { layoutKind = "global::" + layoutKind; } var args = new List <string>(); args.Add(layoutKind); if (type.SizeOf != 0) { string sizeOf = string.Format("Size={0}", type.SizeOf); args.Add(sizeOf); } if (type.Alignment != 0) { string pack = string.Format("Pack={0}", type.Alignment); args.Add(pack); } if (type.StringFormat != StringFormatKind.Ansi) { string charset = string.Format("CharSet={0}System.Runtime.InteropServices.CharSet.{1}", _forCompilationIncludeGlobalprefix ? "global::" : "", type.StringFormat); args.Add(charset); } if (IncludeAttribute(structLayout)) { WriteFakeAttribute(structLayout.FullTypeName, args.ToArray()); } } WriteVisibility(TypeHelper.TypeVisibilityAsTypeMemberVisibility(type)); IMethodDefinition invoke = type.GetInvokeMethod(); if (invoke != null) { Contract.Assert(type.IsDelegate); if (invoke.IsMethodUnsafe()) { WriteKeyword("unsafe"); } WriteKeyword("delegate"); WriteTypeName(invoke.Type); WriteIdentifier(namedType.Name); if (type.IsGeneric) { WriteGenericParameters(type.GenericParameters); } WriteParameters(invoke.Parameters, invoke.ContainingType); if (type.IsGeneric) { WriteGenericContraints(type.GenericParameters); } WriteSymbol(";"); } else { WriteTypeModifiers(type); WriteIdentifier(namedType.Name); Contract.Assert(!(type is IGenericTypeInstance), "Currently don't support generic type instances if we hit this then add support"); if (type.IsGeneric) { WriteGenericParameters(type.GenericParameters); } WriteBaseTypes(type); if (type.IsGeneric) { WriteGenericContraints(type.GenericParameters); } if (type.IsEnum) { WriteEnumType(type); } } }
public void WriteTypeDeclaration(ITypeDefinition type) { INamedTypeDefinition namedType = (INamedTypeDefinition)type; WriteAttributes(type.Attributes); WriteAttributes(type.SecurityAttributes); //TODO: We should likely add support for the SerializableAttribute something like: // if (type.IsSerializable) WriteFakeAttribute("System.Serializable"); // But we need also consider if this attribute is filtered out or not but I guess // we have the same problem with all the fake attributes at this point. if (type.IsStruct && type.Layout != LayoutKind.Auto) { // What about the Pack, and CharSet properties? string structLayout = "System.Runtime.InteropServices.StructLayoutAttribute"; string layoutKind = string.Format("System.Runtime.InteropServices.LayoutKind.{0}", type.Layout.ToString()); if (type.SizeOf != 0) { string sizeOf = string.Format("Size={0}", type.SizeOf); WriteFakeAttribute(structLayout, layoutKind, sizeOf); } else { WriteFakeAttribute(structLayout, layoutKind); } } WriteVisibility(TypeHelper.TypeVisibilityAsTypeMemberVisibility(type)); IMethodDefinition invoke = type.GetInvokeMethod(); if (invoke != null) { Contract.Assert(type.IsDelegate); if (invoke.IsMethodUnsafe()) { WriteKeyword("unsafe"); } WriteKeyword("delegate"); WriteTypeName(invoke.Type); WriteIdentifier(namedType.Name); if (type.IsGeneric) { WriteGenericParameters(type.GenericParameters); } WriteParameters(invoke.Parameters); if (type.IsGeneric) { WriteGenericContraints(type.GenericParameters); } WriteSymbol(";"); } else { WriteTypeModifiers(type); WriteIdentifier(namedType.Name); Contract.Assert(!(type is IGenericTypeInstance), "Currently don't support generic type instances if we hit this then add support"); if (type.IsGeneric) { WriteGenericParameters(type.GenericParameters); } WriteBaseTypes(type); if (type.IsGeneric) { WriteGenericContraints(type.GenericParameters); } if (type.IsEnum) { WriteEnumType(type); } } }
private void WriteMethodModifiers(IMethodDefinition method) { if (method.IsMethodUnsafe()) WriteKeyword("unsafe"); if (method.IsStatic) WriteKeyword("static"); if (method.IsVirtual) { if (method.IsNewSlot) { if (method.IsAbstract) WriteKeyword("abstract"); else if (!method.IsSealed) // non-virtual interfaces implementations are sealed virtual newslots WriteKeyword("virtual"); } else { if (method.IsAbstract) WriteKeyword("abstract"); else if (method.IsSealed) WriteKeyword("sealed"); WriteKeyword("override"); } } }