CGCSharpCodeGenerator.swift

public enum CGCSharpCodeGeneratorDialect {
	case Standard
	case Hydrogene
}

public class CGCSharpCodeGenerator : CGCStyleCodeGenerator {

	public init() {
		super.init()

		// current as of Elements 8.1 and C# 6.0
		keywords = ["__arglist", "__aspect", "__autoreleasepool", "__block", "__inline", "__extension", "__makeref", "__mapped",
					"__reftype", "__refvalue", "__selector", "__strong", "__unretained", "__weak",
					"abstract", "add", "as", "ascending", "assembly", "async", "await", "base", "bool", "break", "by", "byte",
					"case", "catch", "char", "checked", "class", "const", "continue", "decimal", "default", "delegate", "descending", "do", "double", "dynamic",
					"else", "enum", "equals", "event", "explicit", "extern", "false", "finally", "fixed", "float", "for", "foreach", "from", "get", "goto", "group",
					"if", "implicit", "in", "int", "interface", "internal", "into", "is", "join", "let", "lock", "long", "module", "namespace", "new", "null",
					"object", "on", "operator", "orderby", "out", "override", "params", "partial", "private", "protected", "public",
					"readonly", "ref", "remove", "return", "sbyte", "sealed", "select", "set", "short", "sizeof", "stackalloc", "static", "string", "struct", "switch",
					"this", "throw", "true", "try", "typeof", "uint", "ulong", "unchecked", "unsafe", "ushort", "using", "value",
					"var", "virtual", "void", "volatile", "where", "while", "yield"].ToList() as! List<String>
	}

	public var Dialect: CGCSharpCodeGeneratorDialect = .Standard

	public convenience init(dialect: CGCSharpCodeGeneratorDialect) {
		init()
		Dialect = dialect
	}

	public override var defaultFileExtension: String { return "cs" }

	override func escapeIdentifier(_ name: String) -> String {
		return "@\(name)"
	}

	override func generateHeader() {

		super.generateHeader()
		for i in currentUnit.Imports {
			generateImport(i)
		}
		AppendLine()
		if let namespace = currentUnit.Namespace {
			Append("namespace")
			Append(" ")
			generateIdentifier(namespace.Name, alwaysEmitNamespace: true)
			AppendLine()
			AppendLine("{")
			incIndent()
		}
	}

	override func generateFooter() {
		if let namespace = currentUnit.Namespace {
			decIndent()
			AppendLine("}")
		}
	}

	override func generateImports() {
		// no-op, we add imports as part of header
	}

	override func generateImport(_ imp: CGImport) {
		if imp.StaticClass != nil {
			Append("using static ")
			generateIdentifier(imp.StaticClass!.Name, alwaysEmitNamespace: true)
			AppendLine(";")
		} else {
			Append("using ")
			generateIdentifier(imp.Namespace!.Name, alwaysEmitNamespace: true)
			AppendLine(";")
		}
	}

	override func generateGlobals() {
		if let globals = currentUnit.Globals, globals.Count > 0{
			AppendLine("public static partial class __Global")
			AppendLine("{")
			incIndent()
			super.generateGlobals()
			decIndent()
			AppendLine("}")
			AppendLine()
		}
	}

	/*
	override func generateInlineComment(_ comment: String) {
		// handled in base
	}
	*/

	//
	// Statements
	//

	// in C-styleCG Base class
	/*
	override func generateBeginEndStatement(_ statement: CGBeginEndBlockStatement) {
		// handled in base
	}
	*/

	/*
	override func generateIfElseStatement(_ statement: CGIfThenElseStatement) {
		// handled in base
	}
	*/

	/*
	override func generateForToLoopStatement(_ statement: CGForToLoopStatement) {
		// handled in base
	}
	*/

	override func generateForEachLoopStatement(_ statement: CGForEachLoopStatement) {
		Append("foreach (")
		if let type = statement.LoopVariableType {
			generateTypeReference(type)
			Append(" ")
		}
		generateSingleNameOrTupleWithNames(statement.LoopVariableNames)
		Append(" in ")
		generateExpression(statement.Collection)
		AppendLine(")")
		generateStatementIndentedUnlessItsABeginEndBlock(statement.NestedStatement)
	}

	/*
	override func generateWhileDoLoopStatement(_ statement: CGWhileDoLoopStatement) {
		// handled in base
	}
	*/

	/*
	override func generateDoWhileLoopStatement(_ statement: CGDoWhileLoopStatement) {
		// handled in base
	}
	*/

	/*
	override func generateInfiniteLoopStatement(_ statement: CGInfiniteLoopStatement) {
		// handled in base
	}
	*/

	/*
	override func generateSwitchStatement(_ statement: CGSwitchStatement) {
		// handled in base
	}
	*/

	override func generateLockingStatement(_ statement: CGLockingStatement) {
		Append("lock (")
		generateExpression(statement.Expression)
		AppendLine(")")
		generateStatementIndentedUnlessItsABeginEndBlock(statement.NestedStatement)
	}

	override func generateUsingStatement(_ statement: CGUsingStatement) {
		Append("using (")
		if let name = statement.Name {
			if let type = statement.`Type` {
				generateTypeReference(type)
				Append(" ")
			} else {
				Append("var ")
			}
			generateIdentifier(name)
			Append(" = ")
		}
		generateExpression(statement.Value)
		AppendLine(")")
		generateStatementIndentedUnlessItsABeginEndBlock(statement.NestedStatement)
	}

	override func generateAutoReleasePoolStatement(_ statement: CGAutoReleasePoolStatement) {
		if Dialect == CGCSharpCodeGeneratorDialect.Hydrogene {
			AppendLine("using (__autoreleasepool)")
			generateStatementIndentedUnlessItsABeginEndBlock(statement.NestedStatement)
		} else {
			assert(false, "generateAutoReleasePoolStatement is not supported in C#, except in Hydrogene")
		}
	}

	override func generateCheckedStatement(_ statement: CGCheckedStatement) {
		AppendLine("checked")
		generateStatementIndentedUnlessItsABeginEndBlock(statement.NestedStatement)
	}

	override func generateUnsafeStatement(_ statement: CGCUnsafeStatement) {
		AppendLine("unsafe")
		generateStatementIndentedUnlessItsABeginEndBlock(statement.NestedStatement)
	}

	override func generateTryFinallyCatchStatement(_ statement: CGTryFinallyCatchStatement) {
		AppendLine("try")
		AppendLine("{")
		incIndent()
		generateStatements(statement.Statements)
		decIndent()
		AppendLine("}")
		if let finallyStatements = statement.FinallyStatements, finallyStatements.Count > 0 {
			AppendLine("finally")
			AppendLine("{")
			incIndent()
			generateStatements(finallyStatements)
			decIndent()
			AppendLine("}")
		}
		if let catchBlocks = statement.CatchBlocks, catchBlocks.Count > 0 {
			for b in catchBlocks {
				if let name = b.Name, let type = b.`Type` {
					Append("catch (")
					generateTypeReference(type)
					Append(" ")
					generateIdentifier(name)
					AppendLine(")")
					AppendLine("{")
				} else {
					AppendLine("__catch ")
					AppendLine("{")
				}
				incIndent()
				generateStatements(b.Statements)
				decIndent()
				AppendLine("}")
			}
		}
	}

	/*
	override func generateReturnStatement(_ statement: CGReturnStatement) {
		// handled in base
	}
	*/

	override func generateYieldExpression(_ statement: CGYieldExpression) {
		Append("yield ")
		generateExpression(statement.Value)
	}

	override func generateThrowExpression(_ statement: CGThrowExpression) {
		if let value = statement.Exception {
			Append("throw ")
			generateExpression(value)
		} else {
			Append("throw")
		}
	}

	/*
	override func generateBreakStatement(_ statement: CGBreakStatement) {
		// handled in base
	}
	*/

	/*
	override func generateContinueStatement(_ statement: CGContinueStatement) {
		// handled in base
	}
	*/

	override func generateVariableDeclarationStatement(_ statement: CGVariableDeclarationStatement) {
		if let type = statement.`Type` {
			generateTypeReference(type)
			Append(" ")
		} else {
			Append("var ")
		}
		generateIdentifier(statement.Name)
		if let value = statement.Value {
			Append(" = ")
			generateExpression(value)
		}
		AppendLine(";")
	}

	/*
	override func generateAssignmentStatement(_ statement: CGAssignmentStatement) {
		// handled in base
	}
	*/

	override func generateConstructorCallStatement(_ statement: CGConstructorCallStatement) {
		Append("// ")
		cSharpGenerateInlineConstructorCallStatement(statement)
		AppendLine()
	}

	private func cSharpGenerateInlineConstructorCallStatement(_ statement: CGConstructorCallStatement) {
		if let callSite = statement.CallSite {
			if callSite is CGInheritedExpression {
				Append("base")
			} else if callSite is CGSelfExpression {
				Append("this")
			} else {
				assert(false, "Unsupported call site for constructor call.")
			}
		}

		if let name = statement.ConstructorName {
			Append(" ")
			Append(name)
		}
		Append("(")
		cSharpGenerateCallParameters(statement.Parameters)
		Append(")")
	}

	override func generateLocalMethodStatement(_ method: CGLocalMethodStatement) {
		if let returnType = method.ReturnType {
			returnType.startLocation = currentLocation
			generateTypeReference(returnType)
			returnType.endLocation = currentLocation
			Append(" ")
		} else {
			Append("void ")
		}
		generateIdentifier(method.Name)
		//cSharpGenerateGenericParameters(method.GenericParameters)
		Append("(")
		cSharpGenerateDefinitionParameters(method.Parameters)
		Append(")")
		//cSharpGenerateGenericConstraints(method.GenericParameters)
		AppendLine()

		AppendLine("{")
		incIndent()
		generateStatements(variables: method.LocalVariables)
		generateStatements(method.Statements)
		decIndent()
		AppendLine("}")
	}

	//
	// Expressions
	//

	/*
	override func generateNamedIdentifierExpression(_ expression: CGNamedIdentifierExpression) {
		// handled in base
	}
	*/

	/*
	override func generateAssignedExpression(_ expression: CGAssignedExpression) {
		// handled in base
	}
	*/

	/*
	override func generateSizeOfExpression(_ expression: CGSizeOfExpression) {
		// handled in base
	}
	*/

	override func generateTypeOfExpression(_ expression: CGTypeOfExpression) {
		Append("typeof(")
		generateExpression(expression.Expression)
		Append(")")
	}

	override func generateDefaultExpression(_ expression: CGDefaultExpression) {

	}

	override func generateSelectorExpression(_ expression: CGSelectorExpression) {
		if Dialect == CGCSharpCodeGeneratorDialect.Hydrogene {
			Append("__selector(\(expression.Name))")
		} else {
			assert(false, "generateSelectorExpression is not supported in C#, except in Hydrogene")
		}
	}

	override func generateTypeCastExpression(_ cast: CGTypeCastExpression) {
		if cast.ThrowsException {
			Append("((")
			generateTypeReference(cast.TargetType)
			Append(")(")
			generateExpression(cast.Expression)
			Append("))")
		} else {
			Append("(")
			generateExpression(cast.Expression)
			Append(" as ")
			generateTypeReference(cast.TargetType)
			Append(")")
		}
	}

	override func generateInheritedExpression(_ expression: CGInheritedExpression) {
		Append("base")
	}

	override func generateMappedExpression(_ expression: CGMappedExpression) {
		Append("__mapped")
	}

	override func generateOldExpression(_ expression: CGOldExpression) {
		Append("__old")
	}

	override func generateSelfExpression(_ expression: CGSelfExpression) {
		Append("this")
	}

	override func generateNilExpression(_ expression: CGNilExpression) {
		Append("null")
	}

	override func generatePropertyValueExpression(_ expression: CGPropertyValueExpression) {
		Append("value")
	}

	override func generateAwaitExpression(_ expression: CGAwaitExpression) {
		Append("await ")
		generateExpression(expression.Expression)
	}

	override func generateAnonymousMethodExpression(_ method: CGAnonymousMethodExpression) {
		Append("(")
		helpGenerateCommaSeparatedList(method.Parameters) { param in
			self.generateParameterDefinition(param)
		}
		AppendLine(") => {")
		incIndent()
		generateStatements(variables: method.LocalVariables)
		generateStatementsSkippingOuterBeginEndBlock(method.Statements)
		decIndent()
		Append("}")
	}

	override func generateAnonymousTypeExpression(_ type: CGAnonymousTypeExpression) {
		Append("new ")
		if let ancestor = type.Ancestor {
			//75413: C#: syntax for ancestors in anonymous types?
			Append("/* ")
			generateTypeReference(ancestor, ignoreNullability: true)
			Append(" */ ")
		}
		AppendLine("{")
		incIndent()
		helpGenerateCommaSeparatedList(type.Members) { m in

			if let member = m as? CGAnonymousPropertyMemberDefinition {

				self.generateIdentifier(m.Name)
				self.Append(" = ")
				self.generateExpression(member.Value)

			} else if let member = m as? CGAnonymousMethodMemberDefinition {

				self.generateStatement(CGUnsupportedStatement("methods are not supported in anonymous classes in C#."))
			}
		}
		decIndent()
		Append(" }")
	}

	/*
	override func generatePointerDereferenceExpression(_ expression: CGPointerDereferenceExpression) {
		// handled in base
	}
	*/

	override func generateUnaryOperatorExpression(_ expression: CGUnaryOperatorExpression) {
		if let `operator` = expression.Operator, `operator` == .ForceUnwrapNullable && Dialect == .Hydrogene {
			generateExpression(expression.Value)
			Append("!")
		} else {
			super.generateUnaryOperatorExpression(expression)
		}
	}

	/*
	override func generateBinaryOperatorExpression(_ expression: CGBinaryOperatorExpression) {
		// handled in base
	}
	*/

	/*
	override func generateUnaryOperator(_ `operator`: CGUnaryOperatorKind) {
		// handled in base
	}
	*/

	override func generateBinaryOperator(_ `operator`: CGBinaryOperatorKind) {
		switch (`operator`) {
			case .AddEvent: Append("+=")
			case .RemoveEvent: Append("-=")
			default: super.generateBinaryOperator(`operator`)
		}
	}

	/*
	override func generateIfThenElseExpression(_ expression: CGIfThenElseExpression) {
		// handled in base
	}
	*/

	/*
	override func generateArrayElementAccessExpression(_ expression: CGArrayElementAccessExpression) {
		// handled in base
	}
	*/

	internal func csharpGenerateStorageModifierPrefixIfNeeded(_ storageModifier: CGStorageModifierKind) {
		switch storageModifier {
			case .Strong: break
			case .Weak: Append("__weak ")
			case .Unretained: Append("__unretained ")
		}
	}

	internal func cSharpGenerateCallSiteForExpression(_ expression: CGMemberAccessExpression) {
		if let callSite = expression.CallSite {
			generateExpression(callSite)
			if (expression.Name != "") {
				if expression.NilSafe {
					Append("?.")
				} else {
					Append(".")
				}
			}
		}
	}

	func cSharpGenerateCallParameters(_ parameters: List<CGCallParameter>) {
		for p in 0 ..< parameters.Count {
			let param = parameters[p]
			if p > 0 {
				if Dialect == .Hydrogene, let name = param.Name {
					Append(") ")
					generateIdentifier(name)
					Append("(")
				} else {
					Append(", ")
				}
			}
			switch param.Modifier {
				case .Var: self.Append("ref ")
				case .Out: self.Append("out ")
				default:
			}
			generateExpression(param.Value)
		}
	}

	override func generateConditionStart(_ condition: CGConditionalDefine) {
		// repeated as c# does not have ifndef while C does.
		Append("#if ")
		generateExpression(condition.Expression)
		AppendLine()
	}

	func cSharpGenerateAttributeParameters(_ parameters: List<CGCallParameter>) {
		for p in 0 ..< parameters.Count {
			let param = parameters[p]
			if p > 0 {
				Append(", ")
			}
			if let name = param.Name {
				generateIdentifier(name)
				Append(" = ")
			}
			generateExpression(param.Value)
		}
	}

	override func generateParameterDefinition(_ param: CGParameterDefinition) {
		var isXMLDocPresent = self.isXmlDocumentationPresent(param.XmlDocumentation);
		if isXMLDocPresent {
			self.incIndent();
		}
		self.generateXmlDocumentationStatement(param.XmlDocumentation)
		switch param.Modifier {
			case .Var: Append("ref ")
			case .Const: Append("const ") //todo: Oxygene ony?
			case .Out: Append("out ")
			case .Params: Append("params ")
			default:
		}
		if let type = param.`Type` {
			generateTypeReference(type)
		}
		Append(" ")
		generateIdentifier(param.Name)
		if let defaultValue = param.DefaultValue {
			Append(" = ")
			generateExpression(defaultValue)
		}
		if isXMLDocPresent {
			self.decIndent();
		}
	}

	func cSharpGenerateDefinitionParameters(_ parameters: List<CGParameterDefinition>) {
		for p in 0 ..< parameters.Count {
			let param = parameters[p]
			if p > 0 {
				if Dialect == .Hydrogene, let externalName = param.ExternalName {
					Append(") ")
					param.startLocation = currentLocation
					generateIdentifier(externalName)
					Append("(")
				} else {
					Append(", ")
					param.startLocation = currentLocation
				}
			} else {
				param.startLocation = currentLocation
			}

			generateParameterDefinition(param)
			param.endLocation = currentLocation
		}
	}

	func cSharpGenerateGenericParameters(_ parameters: List<CGGenericParameterDefinition>?) {
		if let parameters = parameters, parameters.Count > 0 {
			Append("<")
			helpGenerateCommaSeparatedList(parameters) { param in
				if let variance = param.Variance {
					switch variance {
						case .Covariant: self.Append("out ")
						case .Contravariant: self.Append("in ")
					}
				}
				self.generateIdentifier(param.Name)
				//todo: constraints
			}
			Append(">")
		}
	}

	func cSharpGenerateGenericConstraints(_ parameters: List<CGGenericParameterDefinition>?) {
		if let parameters = parameters, parameters.Count > 0 {
			var needsWhere = true
			for param in parameters {
				if let constraints = param.Constraints, constraints.Count > 0 {
					if needsWhere {
						self.Append(", ")
						needsWhere = false
					} else {
						self.Append(", ")
					}
					self.generateIdentifier(param.Name)
					self.Append(": ")
					self.helpGenerateCommaSeparatedList(constraints) { constraint in
						if let constraint = constraint as? CGGenericHasConstructorConstraint {
							self.Append("new()")
						//todo: 72051: Silver: after "if let x = x as? Foo", x still has the less concrete type. Sometimes.
						} else if let constraint2 = constraint as? CGGenericIsSpecificTypeConstraint {
							self.generateTypeReference(constraint2.`Type`)
						} else if let constraint2 = constraint as? CGGenericIsSpecificTypeKindConstraint {
							switch constraint2.Kind {
								case .Class: self.Append("class")
								case .Struct: self.Append("struct")
								case .Interface: self.Append("interface")
							}
						}
					}
				}
			}
		}
	}

	func cSharpGenerateAncestorList(_ type: CGClassOrStructTypeDefinition) {
		if type.Ancestors.Count > 0 || type.ImplementedInterfaces.Count > 0 {
			Append(" : ")
			var needsComma = false
			for ancestor in type.Ancestors {
				if needsComma {
					Append(", ")
				}
				generateTypeReference(ancestor, ignoreNullability: true)
				needsComma = true
			}
			for interface in type.ImplementedInterfaces {
				if needsComma {
					Append(", ")
				}
				generateTypeReference(interface, ignoreNullability: true)
				needsComma = true
			}
		}
	}

	override func generateFieldAccessExpression(_ expression: CGFieldAccessExpression) {
		cSharpGenerateCallSiteForExpression(expression)
		generateIdentifier(expression.Name)
	}

	override func generateMethodCallExpression(_ method: CGMethodCallExpression) {
		cSharpGenerateCallSiteForExpression(method)
		generateIdentifier(method.Name)
		generateGenericArguments(method.GenericArguments)
		Append("(")
		cSharpGenerateCallParameters(method.Parameters)
		Append(")")
	}

	override func generateNewInstanceExpression(_ expression: CGNewInstanceExpression) {
		Append("new ")
		generateExpression(expression.`Type`, ignoreNullability: true)
		if let bounds = expression.ArrayBounds, bounds.Count > 0 {
			Append("[")
			helpGenerateCommaSeparatedList(bounds) { boundExpression in
				self.generateExpression(boundExpression)
			}
			Append("]")
		} else {
			if Dialect == CGCSharpCodeGeneratorDialect.Hydrogene, let name = expression.ConstructorName {
				Append(" ")
				generateIdentifier(name)
			}
			generateGenericArguments(expression.GenericArguments)
			Append("(")
			cSharpGenerateCallParameters(expression.Parameters)
			Append(")")

			if let propertyInitializers = expression.PropertyInitializers, propertyInitializers.Count > 0 {
				Append(" { ")
				helpGenerateCommaSeparatedList(propertyInitializers) { param in
					self.Append(param.Name)
					self.Append(" = ")
					self.generateExpression(param.Value)
				}
				Append(" }")
			}
		}
	}

	override func generatePropertyAccessExpression(_ property: CGPropertyAccessExpression) {
		cSharpGenerateCallSiteForExpression(property)
		generateIdentifier(property.Name)
		if let params = property.Parameters, params.Count > 0 {
			Append("[")
			cSharpGenerateCallParameters(property.Parameters)
			Append("]")
		}
	}

	override func cStyleEscapeSequenceForCharacter(_ ch: Char) -> String {
		if ch <= 0xffff {
			return "\\u\(Convert.ToHexString(Integer(ch), 4))"
		} else {
			return "\\U\(Convert.ToHexString(Integer(ch), 8))"
		}
	}

	/*
	override func generateStringLiteralExpression(_ expression: CGStringLiteralExpression) {
		// handled in base
	}
	*/

	/*
	override func generateCharacterLiteralExpression(_ expression: CGCharacterLiteralExpression) {
		// handled in base
	}
	*/

	/*
	override func generateIntegerLiteralExpression(_ expression: CGIntegerLiteralExpression) {
		switch literalExpression.Base {
			case 1: Append("0b"+literalExpression.StringRepresentation(base:1))
			default: super.generateStringLiteralExpression(expression)
		}
	}
	*/

	/*
	override func generateFloatLiteralExpression(_ literalExpression: CGFloatLiteralExpression) {
		// handled in base
	}
	*/

	override func generateArrayLiteralExpression(_ array: CGArrayLiteralExpression) {
		Append("new ")
		if let elementType = array.ElementType {
			generateTypeReference(elementType)
		}
		Append("[] ")
		Append("{")
		for e in 0 ..< array.Elements.Count {
			if e > 0 {
				Append(", ")
			}
			generateExpression(array.Elements[e])
		}
		Append("}")
	}

	override func generateSetLiteralExpression(_ expression: CGSetLiteralExpression) {
		assert(false, "Sets are not supported in C#")
	}

	override func generateDictionaryExpression(_ dictionary: CGDictionaryLiteralExpression) {

	}

	/*
	override func generateTupleExpression(_ expression: CGTupleLiteralExpression) {
		// default handled in base
	}
	*/

	override func generateSetTypeReference(_ setType: CGSetTypeReference, ignoreNullability: Boolean = false) {
		assert(false, "generateSetTypeReference is not supported in C#")
	}

	override func generateSequenceTypeReference(_ sequence: CGSequenceTypeReference, ignoreNullability: Boolean = false) {
		if Dialect == CGCSharpCodeGeneratorDialect.Hydrogene {
			Append("ISequence<")
			generateTypeReference(sequence.`Type`)
			Append(">")
			if !ignoreNullability {
				cSharpGenerateSuffixForNullability(sequence)
			}
		} else {
			assert(false, "generateSequenceTypeReference is not supported in C#, except in Hydrogene")
		}
	}

	//
	// Type Definitions
	//

	override func generateAttribute(_ attribute: CGAttribute, inline: Boolean) {
		Append("[")
		generateAttributeScope(attribute)
		generateTypeReference(attribute.Type)
		if let parameters = attribute.Parameters, parameters.Count > 0 {
			Append("(")
			cSharpGenerateAttributeParameters(parameters)
			Append(")")
		}
		Append("]")
		if let comment = attribute.Comment {
			Append(" ")
			generateSingleLineCommentStatement(comment)
		} else {
			if inline {
				Append(" ")
			} else {
				AppendLine()
			}
		}
	}

	override func generateAttributeScope(_ attribute: CGAttribute) {
		if let scope = attribute.Scope {
			switch scope {
				case .Assembly: Append("assembby:")
				case .Module: Append("module:")
				case .Global: Append("/*global:*/")
				case .Result: Append("result:")
				case .Parameter: Append("param:")
				case .Field: Append("field:")
				case .Getter: Append("/*get:*/")
				case .Setter: Append("/*set:*/")
				case .Type: Append("type:")
				case .Method: Append("method:")
				case .Event: Append("event:")
				case .Property: Append("property:")
			}
		}
	}

	func cSharpGenerateTypeVisibilityPrefix(_ visibility: CGTypeVisibilityKind) {
		switch visibility {
			case .Unspecified: break /* no-op */
			case .Unit: Append("internal ")
			case .Assembly: Append("internal ")
			case .Public: Append("public ")
		}
	}

	func cSharpGenerateMemberTypeVisibilityPrefix(_ visibility: CGMemberVisibilityKind) {
		switch visibility {
			case .Unspecified: break /* no-op */
			case .Private: Append("private ")
			case .Unit: fallthrough
			case .UnitOrProtected: fallthrough
			case .UnitAndProtected: fallthrough
			case .Assembly: fallthrough
			case .AssemblyAndProtected: Append("internal ")
			case .AssemblyOrProtected: fallthrough
			case .Protected: Append("protected ")
			case .Published: fallthrough
			case .Public: Append("public ")
		}
	}

	func cSharpGenerateStaticPrefix(_ isStatic: Boolean) {
		if isStatic {
			Append("static ")
		}
	}

	func cSharpGenerateAbstractPrefix(_ isPartial: Boolean) {
		if isPartial {
			Append("abstract ")
		}
	}

	func cSharpGeneratePartialPrefix(_ isAbstract: Boolean) {
		if isAbstract {
			Append("partial ")
		}
	}

	func cSharpGenerateSealedPrefix(_ isSealed: Boolean) {
		if isSealed {
			Append("sealed ")
		}
	}

	func cSharpGenerateVirtualityPrefix(_ member: CGMemberDefinition) {
		switch member.Virtuality {
			//case .None
			case .Virtual: Append("virtual ")
			case .Abstract: Append("abstract ")
			case .Override: Append("override ")
			case .Final: Append("sealed ")
			default:
		}
		if member.Reintroduced {
			Append("new ")
		}
	}

	override func generateAliasType(_ type: CGTypeAliasDefinition) {
		cSharpGenerateTypeVisibilityPrefix(type.Visibility)
		Append("using ")
		generateIdentifier(type.Name)
		cSharpGenerateGenericParameters(type.GenericParameters)
		Append(" = ")
		generateTypeReference(type.ActualType)
		AppendLine(";")
	}

	override func generateBlockType(_ block: CGBlockTypeDefinition) {
		if block.IsPlainFunctionPointer {
			Append("[FunctionPointer] ")
		}
		cSharpGenerateTypeVisibilityPrefix(block.Visibility)
		Append("delegate ")
		if let returnType = block.ReturnType {
			generateTypeReference(returnType)
		} else {
			Append("void")
		}
		Append(" ")
		generateIdentifier(block.Name)
		Append(" (")
		if let parameters = block.Parameters, parameters.Count > 0 {
			cSharpGenerateDefinitionParameters(parameters)
		}
		AppendLine(");")
	}

	override func generateInlineBlockTypeReference(_ type: CGInlineBlockTypeReference, ignoreNullability: Boolean = false) {
		if type.Block.IsPlainFunctionPointer {
			Append("[FunctionPointer] ")
		}
		Append("delegate ")
		if let returnType = type.Block.ReturnType {
			generateTypeReference(returnType)
		} else {
			Append("void")
		}
		Append(" (")
		if let parameters = type.Block.Parameters, parameters.Count > 0 {
			cSharpGenerateDefinitionParameters(parameters)
		}
		Append(")")
	}

	override func generateEnumType(_ type: CGEnumTypeDefinition) {
		cSharpGenerateTypeVisibilityPrefix(type.Visibility)
		Append("enum ")
		generateIdentifier(type.Name)
		//ToDo: generic constraints
		if let baseType = type.BaseType {
			Append(" : ")
			generateTypeReference(baseType)
		}
		AppendLine()
		AppendLine("{")
		incIndent()
		helpGenerateCommaSeparatedList(type.Members, wrapAlways: wrapEnums) {m in
			if let member = m as? CGEnumValueDefinition {
				self.generateXmlDocumentationStatement(member.XmlDocumentation)
				self.generateAttributes(member.Attributes, inline: true)
				self.generateIdentifier(member.Name)
				if let value = member.Value {
					self.Append(" = ")
					self.generateExpression(value)
				}
			}
		}

		AppendLine()

		decIndent()
		AppendLine("}")
	}

	override func generateClassTypeStart(_ type: CGClassTypeDefinition) {
		cSharpGenerateTypeVisibilityPrefix(type.Visibility)
		cSharpGenerateStaticPrefix(type.Static)
		cSharpGenerateAbstractPrefix(type.Abstract)
		cSharpGeneratePartialPrefix(type.Partial)
		cSharpGenerateSealedPrefix(type.Sealed)
		Append("class ")
		generateIdentifier(type.Name)
		cSharpGenerateGenericParameters(type.GenericParameters)
		cSharpGenerateGenericConstraints(type.GenericParameters)
		cSharpGenerateAncestorList(type)
		AppendLine()
		AppendLine("{")
		incIndent()
	}

	override func generateClassTypeEnd(_ type: CGClassTypeDefinition) {
		decIndent()
		AppendLine("}")
	}

	override func generateStructTypeStart(_ type: CGStructTypeDefinition) {
		cSharpGenerateTypeVisibilityPrefix(type.Visibility)
		cSharpGenerateStaticPrefix(type.Static)
		cSharpGenerateAbstractPrefix(type.Abstract)
		cSharpGeneratePartialPrefix(type.Partial)
		cSharpGenerateSealedPrefix(type.Sealed)
		Append("struct ")
		generateIdentifier(type.Name)
		cSharpGenerateGenericParameters(type.GenericParameters)
		cSharpGenerateGenericConstraints(type.GenericParameters)
		cSharpGenerateAncestorList(type)
		AppendLine()
		AppendLine("{")
		incIndent()
	}

	override func generateStructTypeEnd(_ type: CGStructTypeDefinition) {
		decIndent()
		AppendLine("}")
	}

	override func generateInterfaceTypeStart(_ type: CGInterfaceTypeDefinition) {
		cSharpGenerateTypeVisibilityPrefix(type.Visibility)
		cSharpGenerateSealedPrefix(type.Sealed)
		Append("interface ")
		generateIdentifier(type.Name)
		cSharpGenerateGenericParameters(type.GenericParameters)
		cSharpGenerateGenericConstraints(type.GenericParameters)
		cSharpGenerateAncestorList(type)
		AppendLine()
		AppendLine("{")
		incIndent()
	}

	override func generateInterfaceTypeEnd(_ type: CGInterfaceTypeDefinition) {
		decIndent()
		AppendLine("}")
	}

	override func generateExtensionTypeStart(_ type: CGExtensionTypeDefinition) {
		AppendLine("[Category]")
		cSharpGenerateTypeVisibilityPrefix(type.Visibility)
		cSharpGenerateStaticPrefix(type.Static)
		Append("class ")
		generateIdentifier(type.Name)
		cSharpGenerateAncestorList(type)
		AppendLine()
		AppendLine("{")
		incIndent()
	}

	override func generateExtensionTypeEnd(_ type: CGExtensionTypeDefinition) {
		decIndent()
		AppendLine("}")
	}

	override func generateMappedTypeStart(_ type: CGMappedTypeDefinition) {
		cSharpGenerateTypeVisibilityPrefix(type.Visibility)
		cSharpGenerateStaticPrefix(type.Static)
		Append("__mapped class ")
		generateIdentifier(type.Name)
		cSharpGenerateAncestorList(type)
		Append(" => ")
		generateTypeReference(type.mappedType)
		AppendLine()
		AppendLine("{")
		incIndent()
	}

	override func generateMappedTypeEnd(_ type: CGMappedTypeDefinition) {
		decIndent()
		AppendLine("}")
	}

	//
	// Type Members
	//

	override func generateMethodDefinition(_ method: CGMethodDefinition, type: CGTypeDefinition) {

		if type is CGInterfaceTypeDefinition {
			if method.Optional {
				Append("[Optional] ")
			}
			cSharpGenerateStaticPrefix(method.Static || type.Static)
		} else {
			cSharpGenerateMemberTypeVisibilityPrefix(method.Visibility)
			cSharpGenerateStaticPrefix(method.Static || type.Static)
			if method.Awaitable {
				Append("async ")
			}
			if method.External {
				Append("extern ")
			}
			cSharpGenerateVirtualityPrefix(method)
		}
		if let returnType = method.ReturnType {
			returnType.startLocation = currentLocation
			generateTypeReference(returnType)
			returnType.endLocation = currentLocation
			Append(" ")
		} else {
			Append("void ")
		}
		generateIdentifier(method.Name)
		cSharpGenerateGenericParameters(method.GenericParameters)
		Append("(")
		cSharpGenerateDefinitionParameters(method.Parameters)
		Append(")")
		cSharpGenerateGenericConstraints(method.GenericParameters)

		if type is CGInterfaceTypeDefinition || method.Virtuality == CGMemberVirtualityKind.Abstract || method.External || definitionOnly {
			AppendLine(";")
			return
		}

		AppendLine()
		AppendLine("{")
		incIndent()

		if let conditions = method.Preconditions, conditions.Count > 0 {
			AppendLine("__require")
			AppendLine("{")
			incIndent()
			generateInvariantExpressions(conditions)
			decIndent()
			AppendLine("}")
		}

		generateStatements(variables: method.LocalVariables)
		generateStatements(method.Statements)

		if let conditions = method.Postconditions, conditions.Count > 0 {
			AppendLine("__ensure")
			AppendLine("{")
			incIndent()
			generateInvariantExpressions(conditions)
			decIndent()
			AppendLine("}")
		}

		decIndent()
		AppendLine("}")
	}

	override func generateConstructorDefinition(_ ctor: CGConstructorDefinition, type: CGTypeDefinition) {
		if type is CGInterfaceTypeDefinition {
		} else {
			cSharpGenerateMemberTypeVisibilityPrefix(ctor.Visibility)
		}
		cSharpGenerateStaticPrefix(ctor.Static && !type.Static)
		cSharpGenerateVirtualityPrefix(ctor)

		if length(ctor.Name) > 0 {
			Append("this ")
			generateIdentifier(ctor.Name)
		} else {
			generateIdentifier(type.Name)
		}
		Append("(")
		cSharpGenerateDefinitionParameters(ctor.Parameters)
		Append(")")
		if let ctorCall = ctor.NestedConstrutorCall {
			Append(" : ")
			cSharpGenerateInlineConstructorCallStatement(ctorCall)
		}

		if ctor.Virtuality == CGMemberVirtualityKind.Abstract || definitionOnly {
			AppendLine(";")
			return
		}

		AppendLine()
		AppendLine("{")
		incIndent()
		generateStatements(variables: ctor.LocalVariables)
		generateStatements(ctor.Statements)
		decIndent()
		AppendLine("}")
	}

	override func generateDestructorDefinition(_ dtor: CGDestructorDefinition, type: CGTypeDefinition) {
		assert(false, "generateDestructorDefinition is not supported in C#")
	}

	override func generateFinalizerDefinition(_ finalizer: CGFinalizerDefinition, type: CGTypeDefinition) {
		if type is CGInterfaceTypeDefinition {
		} else {
			cSharpGenerateMemberTypeVisibilityPrefix(finalizer.Visibility)
			cSharpGenerateVirtualityPrefix(finalizer)
		}
		Append("~")
		generateIdentifier(type.Name)
		Append("(")
		cSharpGenerateDefinitionParameters(finalizer.Parameters)
		Append(")")

		if finalizer.Virtuality == CGMemberVirtualityKind.Abstract || definitionOnly {
			AppendLine(";")
			return
		}

		AppendLine()
		AppendLine("{")
		incIndent()
		generateStatements(variables: finalizer.LocalVariables)
		generateStatements(finalizer.Statements)
		decIndent()
		AppendLine("}")
	}

	override func generateFieldDefinition(_ field: CGFieldDefinition, type: CGTypeDefinition) {
		cSharpGenerateMemberTypeVisibilityPrefix(field.Visibility)
		cSharpGenerateStaticPrefix(field.Static && !type.Static && !field.Constant)
		var fixedArrayType: Boolean = false
		if let arr = field.Type as? CGArrayTypeReference {
			if let bounds = arr.Bounds, bounds.Count == 1 {
				Append("fixed ");
				fixedArrayType = true;
			}
		}
		if field.Constant {
			Append("const ")
		}

		if field.Volatile {
			Append("volatile ")
		}

		csharpGenerateStorageModifierPrefixIfNeeded(field.StorageModifier)
		if let type = field.`Type` {
			if fixedArrayType {
				generateTypeReference((type as! CGArrayTypeReference).Type)
			} else {
				generateTypeReference(type)
			}
			Append(" ")
		} else {
			Append("var ")
		}
		generateIdentifier(field.Name)
		if fixedArrayType {
			Append("[");
			if let array = field.Type as? CGArrayTypeReference {
				if let bounds = array.Bounds {
					generateExpression(bounds[0].End?);
					Append(" - ");
					generateExpression(bounds[0].Start);
					Append(" + 1");
				}
			}
			Append("]");
		}
		if let value = field.Initializer {
			Append(" = ")
			generateExpression(value)
		}
		AppendLine(";")
	}

	override func generatePropertyDefinition(_ property: CGPropertyDefinition, type: CGTypeDefinition) {
		if !(type is CGInterfaceTypeDefinition) {
			cSharpGenerateMemberTypeVisibilityPrefix(property.Visibility)
			cSharpGenerateStaticPrefix(property.Static && !type.Static)
			cSharpGenerateVirtualityPrefix(property)
		}

		csharpGenerateStorageModifierPrefixIfNeeded(property.StorageModifier)
		if let type = property.`Type` {
			generateTypeReference(type)
			Append(" ")
		} else {
			Append("var ")
		}

		if property.Default {
			Append("this")
		} else {
			generateIdentifier(property.Name)
		}

		if let params = property.Parameters, params.Count > 0 {
			Append("[")
			cSharpGenerateDefinitionParameters(params)
			Append("]")
		}

		func appendGet() {
			if let v = property.GetterVisibility {
				self.cSharpGenerateMemberTypeVisibilityPrefix(v)
			}
			self.Append("get")
		}

		func appendSet() {
			if let v = property.SetterVisibility {
				self.cSharpGenerateMemberTypeVisibilityPrefix(v)
			}
			self.Append("set")
		}

		if property.GetStatements == nil && property.SetStatements == nil && property.GetExpression == nil && property.SetExpression == nil {

			if property.ReadOnly {
				Append(" { ")
				appendGet()
				Append("; }")
			} else if property.WriteOnly {
				Append(" { ")
				appendSet()
				Append("; }")
			} else {
				Append(" { ")
				appendGet()
				Append("; ")
				appendSet()
				Append("; }")
			}
			if let value = property.Initializer {
				Append(" = ")
				generateExpression(value)
				Append(";")
			}
			AppendLine()

		} else {

			if definitionOnly {
				Append("{ ")
				if property.GetStatements != nil || property.GetExpression != nil {
					appendGet()
					Append("; ")
				}
				if property.SetStatements != nil || property.SetExpression != nil {
					appendSet()
					Append("; ")
				}
				Append("}")
				AppendLine()
				return
			}

			AppendLine()
			AppendLine("{")
			incIndent()

			if let getStatements = property.GetStatements {
				appendGet()
				AppendLine()
				AppendLine("{")
				incIndent()
				generateStatementsSkippingOuterBeginEndBlock(getStatements)
				decIndent()
				AppendLine("}")
			} else if let getExpresssion = property.GetExpression {
				appendGet()
				AppendLine()
				AppendLine("{")
				incIndent()
				generateStatement(CGReturnStatement(getExpresssion))
				decIndent()
				AppendLine("}")
			}

			if let setStatements = property.SetStatements {
				appendSet()
				AppendLine()
				AppendLine("{")
				incIndent()
				generateStatementsSkippingOuterBeginEndBlock(setStatements)
				decIndent()
				AppendLine("}")
			} else if let setExpression = property.SetExpression {
				appendSet()
				AppendLine()
				AppendLine("{")
				incIndent()
				generateStatement(CGAssignmentStatement(setExpression, CGPropertyValueExpression.PropertyValue))
				decIndent()
				AppendLine("}")
			}

			decIndent()
			Append("}")

			if let value = property.Initializer {
				Append(" = ")
				generateExpression(value)
				Append(";")
			}
			AppendLine()
		}
	}

	override func generateEventDefinition(_ event: CGEventDefinition, type: CGTypeDefinition) {
		cSharpGenerateMemberTypeVisibilityPrefix(event.Visibility)
		cSharpGenerateStaticPrefix(event.Static && !type.Static)
		cSharpGenerateVirtualityPrefix(event)

		Append("event ")
		if let type = event.`Type` {
			generateTypeReference(type)
			Append(" ")
		}
		generateIdentifier(event.Name)
		AppendLine(";")
	}

	override func generateCustomOperatorDefinition(_ customOperator: CGCustomOperatorDefinition, type: CGTypeDefinition) {

		if type is CGInterfaceTypeDefinition {
			if customOperator.Optional {
				Append("[Optional] ")
			}
			cSharpGenerateStaticPrefix(!type.Static)
		} else {
			cSharpGenerateMemberTypeVisibilityPrefix(customOperator.Visibility)
			cSharpGenerateStaticPrefix(!type.Static)
			cSharpGenerateVirtualityPrefix(customOperator)
		}

		let lowerName = customOperator.Name.ToLower()
		if lowerName == "implicit" || lowerName == "explicit" {

			Append(lowerName)
			Append(" operator")
			if let returnType = customOperator.ReturnType {
				returnType.startLocation = currentLocation
				generateTypeReference(returnType)
				returnType.endLocation = currentLocation
			} else {
				Append("void")
			}

		} else {

			if let returnType = customOperator.ReturnType {
				returnType.startLocation = currentLocation
				generateTypeReference(returnType)
				returnType.endLocation = currentLocation
				Append(" ")
			} else {
				Append("void ")
			}
			Append("operator ")

			if let symbol = wellKnownSymbolForCustomOperator(name: customOperator.Name) {
				Append(symbol)
			} else {
				Append(customOperator.Name)
			}
		}

		Append("(")
		cSharpGenerateDefinitionParameters(customOperator.Parameters)
		Append(")")

		if type is CGInterfaceTypeDefinition || customOperator.Virtuality == CGMemberVirtualityKind.Abstract || customOperator.External || definitionOnly {
			AppendLine(";")
			return
		}

		AppendLine()
		AppendLine("{")
		incIndent()
		generateStatements(variables: customOperator.LocalVariables)
		generateStatements(customOperator.Statements)
		decIndent()
		AppendLine("}")
	}

	override func generateNestedTypeDefinition(_ member: CGNestedTypeDefinition, type: CGTypeDefinition) {
		generateTypeDefinition(member.`Type`)
	}

	//
	// Type References
	//

	func cSharpGenerateSuffixForNullability(_ type: CGTypeReference) {
		if type.DefaultNullability == CGTypeNullabilityKind.NotNullable || (type.Nullability == CGTypeNullabilityKind.NullableNotUnwrapped && Dialect == CGCSharpCodeGeneratorDialect.Hydrogene) {
			//Append("/*default not null*/")
			if type.Nullability == CGTypeNullabilityKind.NullableUnwrapped || type.Nullability == CGTypeNullabilityKind.NullableNotUnwrapped {
				Append("?")
			}
		} else {
			//Append("/*default nullable*/")
			if type.Nullability == CGTypeNullabilityKind.NotNullable {
				//Append("/*not null*/")
				if Dialect == CGCSharpCodeGeneratorDialect.Hydrogene {
					Append("!")
				}
			}
		}
	}

	override func generateNamedTypeReference(_ type: CGNamedTypeReference, ignoreNullability: Boolean = false) {
		super.generateNamedTypeReference(type, ignoreNullability: ignoreNullability)
		if !ignoreNullability {
			cSharpGenerateSuffixForNullability(type)
		}
	}

	override func generatePredefinedTypeReference(_ type: CGPredefinedTypeReference, ignoreNullability: Boolean = false) {
		switch (type.Kind) {
			case .Int: Append("int")
			case .UInt: Append("uint")
			case .Int8: Append("sbyte")
			case .UInt8: Append("byte")
			case .Int16: Append("short")
			case .UInt16: Append("ushort")
			case .Int32: Append("int")
			case .UInt32: Append("uint")
			case .Int64: Append("long")
			case .UInt64: Append("ulong")
			case .IntPtr: Append("IntPtr")
			case .UIntPtr: Append("UIntPtr")
			case .Single: Append("float")
			case .Double: Append("double")
			case .Boolean: Append("bool")
			case .String: Append("string")
			case .AnsiChar: Append("AnsiChar")
			case .UTF16Char: Append("char")
			case .UTF32Char: Append("UInt32")
			case .Dynamic: Append("dynamic")
			case .InstanceType: Append("InstanceType")
			case .Void: Append("void")
			case .Object: Append("object")
			case .Class: Append("Class") // todo: make platform-specific
		}
		if !ignoreNullability {
			cSharpGenerateSuffixForNullability(type)
		}
	}

	/*
	override func generatePointerTypeReference(_ type: CGPointerTypeReference) {
		// handled in base
	}
	*/

	override func generateKindOfTypeReference(_ type: CGKindOfTypeReference, ignoreNullability: Boolean = false) {
		if Dialect == CGCSharpCodeGeneratorDialect.Hydrogene {
			Append("dynamic<")
			generateTypeReference(type.`Type`)
			Append(">")
			if !ignoreNullability {
				cSharpGenerateSuffixForNullability(type)
			}
		} else {
			assert(false, "generateKindOfTypeReference is not supported in C#, except in Hydrogene")
		}
	}

	override func generateTupleTypeReference(_ type: CGTupleTypeReference, ignoreNullability: Boolean = false) {
		Append("(")
		for m in 0 ..< type.Members.Count {
			if m > 0 {
				Append(", ")
			}
			generateTypeReference(type.Members[m])
		}
		Append(")")
		if !ignoreNullability {
			cSharpGenerateSuffixForNullability(type)
		}
	}

	override func generateArrayTypeReference(_ array: CGArrayTypeReference, ignoreNullability: Boolean = false) {
		generateTypeReference(array.`Type`)
		if let bounds = array.Bounds {
			var count = bounds.Count
			if count == 0 {
				count = 1
			}
			for b in 0 ..< count {
				Append("[]")
			}
		} else {
			Append("[]")
		}
		if !ignoreNullability {
			cSharpGenerateSuffixForNullability(array)
		}
	}

	override func generateDictionaryTypeReference(_ type: CGDictionaryTypeReference, ignoreNullability: Boolean = false) {
		Append("Dictionary<")
		generateTypeReference(type.KeyType)
		Append(",")
		generateTypeReference(type.ValueType)
		Append(">")
		if !ignoreNullability {
			cSharpGenerateSuffixForNullability(type)
		}
	}
}