Serde.hs

module Hydra.Ext.Java.Serde where

import Hydra.Util.Codetree.Script
import qualified Hydra.Util.Codetree.Ast as CT
import qualified Hydra.Ext.Java.Syntax as Java

import qualified Data.List as L
import qualified Data.Maybe as Y


withComments :: Maybe String -> CT.Expr -> CT.Expr
withComments mc expr = case mc of
    Nothing -> expr
    Just c -> newlineSep [writeComments c, expr]
  where
    writeComments c = cst $ "/**\n" ++ unlines (toLine <$> (lines $ sanitizeJavaComment c)) ++ " */"
      where
        toLine l = " * " ++ l
    sanitizeJavaComment s = L.concat (fromChar <$> s)
      where
        fromChar c = case c of
          '<' -> "&lt;"
          '>' -> "&gt;"
          _ -> [c]

writeAdditionalBound :: Java.AdditionalBound -> CT.Expr
writeAdditionalBound _ = cst "TODO:AdditionalBound"

writeAdditiveExpression :: Java.AdditiveExpression -> CT.Expr
writeAdditiveExpression e = case e of
  Java.AdditiveExpressionUnary m -> writeMultiplicativeExpression m
  Java.AdditiveExpressionPlus (Java.AdditiveExpression_Binary lhs rhs) ->
    infixWs "+" (writeAdditiveExpression lhs) (writeMultiplicativeExpression rhs)
  Java.AdditiveExpressionMinus (Java.AdditiveExpression_Binary lhs rhs) ->
    infixWs "-" (writeAdditiveExpression lhs) (writeMultiplicativeExpression rhs)

writeAmbiguousName :: Java.AmbiguousName -> CT.Expr
writeAmbiguousName (Java.AmbiguousName parts) = dotSep (writeIdentifier <$> parts)

writeAndExpression :: Java.AndExpression -> CT.Expr
writeAndExpression (Java.AndExpression eqs) = infixWsList "&" (writeEqualityExpression <$> eqs)

writeAnnotatedIdentifier :: Java.AnnotatedIdentifier -> CT.Expr
writeAnnotatedIdentifier (Java.AnnotatedIdentifier anns id) = writeIdentifier id -- Note: ignoring annotations for now

writeAnnotation :: Java.Annotation -> CT.Expr
writeAnnotation ann = case ann of
  Java.AnnotationNormal n -> writeNormalAnnotation n
  Java.AnnotationMarker m -> writeMarkerAnnotation m
  Java.AnnotationSingleElement s -> writeSingleElementAnnotation s

writeAnnotationTypeDeclaration :: Java.AnnotationTypeDeclaration -> CT.Expr
writeAnnotationTypeDeclaration _ = cst "TODO:AnnotationTypeDeclaration"

writeArrayAccess :: Java.ArrayAccess -> CT.Expr
writeArrayAccess _ = cst "TODO:ArrayAccess"

writeArrayCreationExpression :: Java.ArrayCreationExpression -> CT.Expr
writeArrayCreationExpression _ = cst "TODO:ArrayCreationExpression"

writeArrayInitializer :: Java.ArrayInitializer -> CT.Expr
writeArrayInitializer _ = cst "TODO:ArrayInitializer"

writeArrayType :: Java.ArrayType -> CT.Expr
writeArrayType _ = cst "TODO:ArrayType"

writeAssertStatement :: Java.AssertStatement -> CT.Expr
writeAssertStatement _ = cst "TODO:AssertStatement"

writeAssignment :: Java.Assignment -> CT.Expr
writeAssignment (Java.Assignment lhs op rhs) = infixWs ctop (writeLeftHandSide lhs) (writeExpression rhs)
  where
    ctop = case op of
      Java.AssignmentOperatorSimple -> "="
      Java.AssignmentOperatorTimes -> "*="
      Java.AssignmentOperatorDiv -> "/="
      Java.AssignmentOperatorMod -> "%="
      Java.AssignmentOperatorPlus -> "+="
      Java.AssignmentOperatorMinus -> "-="
      Java.AssignmentOperatorShiftLeft -> "<<="
      Java.AssignmentOperatorShiftRight -> ">>="
      Java.AssignmentOperatorShiftRightZeroFill -> ">>>="
      Java.AssignmentOperatorAnd -> "&="
      Java.AssignmentOperatorXor -> "^="
      Java.AssignmentOperatorOr -> "|="

writeAssignmentExpression :: Java.AssignmentExpression -> CT.Expr
writeAssignmentExpression e = case e of
  Java.AssignmentExpressionConditional c -> writeConditionalExpression c
  Java.AssignmentExpressionAssignment a -> writeAssignment a

writeBlock :: Java.Block -> CT.Expr
writeBlock (Java.Block stmts) = curlyBlock fullBlockStyle $ newlineSep (writeBlockStatement <$> stmts)

writeBlockStatement :: Java.BlockStatement -> CT.Expr
writeBlockStatement s = case s of
  Java.BlockStatementLocalVariableDeclaration d -> writeLocalVariableDeclarationStatement d
  Java.BlockStatementClass cd -> writeClassDeclaration cd
  Java.BlockStatementStatement s -> writeStatement s

writeBreakStatement :: Java.BreakStatement -> CT.Expr
writeBreakStatement _ = cst "TODO:BreakStatement"

writeCastExpression :: Java.CastExpression -> CT.Expr
writeCastExpression e = case e of
  Java.CastExpressionPrimitive p -> writeCastExpression_Primitive p
  Java.CastExpressionNotPlusMinus npm -> writeCastExpression_NotPlusMinus npm
  Java.CastExpressionLambda l -> writeCastExpression_Lambda l

writeCastExpression_Lambda :: Java.CastExpression_Lambda -> CT.Expr
writeCastExpression_Lambda _ = cst "TODO:CastExpression_Lambda"

writeCastExpression_NotPlusMinus :: Java.CastExpression_NotPlusMinus -> CT.Expr
writeCastExpression_NotPlusMinus (Java.CastExpression_NotPlusMinus rb ex) = spaceSep [
  writeCastExpression_RefAndBounds rb,
  writeUnaryExpression ex]

writeCastExpression_RefAndBounds :: Java.CastExpression_RefAndBounds -> CT.Expr
writeCastExpression_RefAndBounds (Java.CastExpression_RefAndBounds rt adds) = parenList False [spaceSep $ Y.catMaybes [
  Just $ writeReferenceType rt,
  if L.null adds then Nothing else Just $ spaceSep (writeAdditionalBound <$> adds)]]

writeCastExpression_Primitive :: Java.CastExpression_Primitive -> CT.Expr
writeCastExpression_Primitive _ = cst "TODO:CastExpression_Primitive"

writeCharacterLiteral :: Int -> CT.Expr
writeCharacterLiteral _ = cst "TODO:CharacterLiteral"

writeClassBody :: Java.ClassBody -> CT.Expr
writeClassBody (Java.ClassBody decls) = curlyBlock fullBlockStyle $
  doubleNewlineSep (writeClassBodyDeclarationWithComments <$> decls)

writeClassBodyDeclaration :: Java.ClassBodyDeclaration -> CT.Expr
writeClassBodyDeclaration d = case d of
  Java.ClassBodyDeclarationClassMember d -> writeClassMemberDeclaration d
  Java.ClassBodyDeclarationInstanceInitializer i -> writeInstanceInitializer i
  Java.ClassBodyDeclarationStaticInitializer i -> writeStaticInitializer i
  Java.ClassBodyDeclarationConstructorDeclaration d -> writeConstructorDeclaration d

writeClassBodyDeclarationWithComments :: Java.ClassBodyDeclarationWithComments -> CT.Expr
writeClassBodyDeclarationWithComments (Java.ClassBodyDeclarationWithComments d mc) = withComments mc $
  writeClassBodyDeclaration d

writeClassDeclaration :: Java.ClassDeclaration -> CT.Expr
writeClassDeclaration d = case d of
  Java.ClassDeclarationNormal nd -> writeNormalClassDeclaration nd
  Java.ClassDeclarationEnum ed -> writeEnumDeclaration ed

writeClassInstanceCreationExpression :: Java.ClassInstanceCreationExpression -> CT.Expr
writeClassInstanceCreationExpression (Java.ClassInstanceCreationExpression mqual e) = case mqual of
  Nothing -> writeUnqualifiedClassInstanceCreationExpression e
  Just q -> dotSep [writeClassInstanceCreationExpression_Qualifier q, writeUnqualifiedClassInstanceCreationExpression e]

writeClassInstanceCreationExpression_Qualifier :: Java.ClassInstanceCreationExpression_Qualifier -> CT.Expr
writeClassInstanceCreationExpression_Qualifier q = case q of
  Java.ClassInstanceCreationExpression_QualifierExpression en -> writeExpressionName en
  Java.ClassInstanceCreationExpression_QualifierPrimary p -> writePrimary p

writeClassLiteral :: Java.ClassLiteral -> CT.Expr
writeClassLiteral _ = cst "TODO:ClassLiteral"

writeClassMemberDeclaration :: Java.ClassMemberDeclaration -> CT.Expr
writeClassMemberDeclaration d = case d of
  Java.ClassMemberDeclarationField fd -> writeFieldDeclaration fd
  Java.ClassMemberDeclarationMethod md -> writeMethodDeclaration md
  Java.ClassMemberDeclarationClass cd -> writeClassDeclaration cd
  Java.ClassMemberDeclarationInterface id -> writeInterfaceDeclaration id
  Java.ClassMemberDeclarationNone -> semi

writeClassModifier :: Java.ClassModifier -> CT.Expr
writeClassModifier m = case m of
  Java.ClassModifierAnnotation ann -> writeAnnotation ann
  Java.ClassModifierPublic -> cst "public"
  Java.ClassModifierProtected -> cst "protected"
  Java.ClassModifierPrivate -> cst "private"
  Java.ClassModifierAbstract -> cst "abstract"
  Java.ClassModifierStatic -> cst "static"
  Java.ClassModifierFinal -> cst "final"
  Java.ClassModifierStrictfp -> cst "strictfp"

writeClassOrInterfaceType :: Java.ClassOrInterfaceType -> CT.Expr
writeClassOrInterfaceType cit = case cit of
  Java.ClassOrInterfaceTypeClass ct -> writeClassType ct
  Java.ClassOrInterfaceTypeInterface it -> writeInterfaceType it

writeClassOrInterfaceTypeToInstantiate :: Java.ClassOrInterfaceTypeToInstantiate -> CT.Expr
writeClassOrInterfaceTypeToInstantiate (Java.ClassOrInterfaceTypeToInstantiate ids margs) =
  noSep $ Y.catMaybes [
    Just $ dotSep (writeAnnotatedIdentifier <$> ids),
    writeTypeArgumentsOrDiamond <$> margs]

writeClassType :: Java.ClassType -> CT.Expr
writeClassType (Java.ClassType anns qual id args) = noSep $ Y.catMaybes [
    Just $ spaceSep $ Y.catMaybes [
      if L.null anns then Nothing else Just $ commaSep inlineStyle (writeAnnotation <$> anns),
      Just qualifiedId],
    if L.null args then Nothing else Just $ angleBracesList inlineStyle (writeTypeArgument <$> args)]
  where
    qualifiedId = case qual of
      Java.ClassTypeQualifierNone -> writeTypeIdentifier id
      Java.ClassTypeQualifierPackage pkg -> dotSep [writePackageName pkg, writeTypeIdentifier id]
      Java.ClassTypeQualifierParent cit -> dotSep [writeClassOrInterfaceType cit, writeTypeIdentifier id]

writeCompilationUnit :: Java.CompilationUnit -> CT.Expr
writeCompilationUnit u = case u of
  Java.CompilationUnitOrdinary (Java.OrdinaryCompilationUnit mpkg imports types) -> doubleNewlineSep $ Y.catMaybes
      [pkgSec, importsSec, typesSec]
    where
      pkgSec = fmap writePackageDeclaration mpkg
      importsSec = if L.null imports
        then Nothing
        else Just $ newlineSep (writeImportDeclaration <$> imports)
      typesSec = if L.null types
        then Nothing
        else Just $ doubleNewlineSep (writeTypeDeclarationWithComments <$> types)

writeConditionalAndExpression :: Java.ConditionalAndExpression -> CT.Expr
writeConditionalAndExpression (Java.ConditionalAndExpression ors)
  = infixWsList "&&" (writeInclusiveOrExpression <$> ors)

writeConditionalExpression :: Java.ConditionalExpression -> CT.Expr
writeConditionalExpression c = case c of
  Java.ConditionalExpressionSimple co -> writeConditionalOrExpression co
  Java.ConditionalExpressionTernaryCond tc -> writeConditionalExpression_TernaryCond tc
  Java.ConditionalExpressionTernaryLambda tl -> writeConditionalExpression_TernaryLambda tl

writeConditionalExpression_TernaryCond :: Java.ConditionalExpression_TernaryCond -> CT.Expr
writeConditionalExpression_TernaryCond _ = cst "TODO:ConditionalExpression_TernaryCond"

writeConditionalExpression_TernaryLambda :: Java.ConditionalExpression_TernaryLambda -> CT.Expr
writeConditionalExpression_TernaryLambda _ = cst "TODO:ConditionalExpression_TernaryLambda"

writeConditionalOrExpression :: Java.ConditionalOrExpression -> CT.Expr
writeConditionalOrExpression (Java.ConditionalOrExpression ands)
  = infixWsList "||" (writeConditionalAndExpression <$> ands)

writeConstantDeclaration :: Java.ConstantDeclaration -> CT.Expr
writeConstantDeclaration (Java.ConstantDeclaration mods typ vars) = suffixSemi $ spaceSep $ Y.catMaybes [
  if L.null mods then Nothing else Just $ spaceSep (writeConstantModifier <$> mods),
  Just $ writeUnannType typ,
  Just $ commaSep inlineStyle (writeVariableDeclarator <$> vars)]

writeConstantModifier :: Java.ConstantModifier -> CT.Expr
writeConstantModifier _ = cst "TODO:ConstantModifier"

writeConstructorBody :: Java.ConstructorBody -> CT.Expr
writeConstructorBody (Java.ConstructorBody minvoc stmts) = curlyBlock fullBlockStyle $ doubleNewlineSep $ Y.catMaybes [
  writeExplicitConstructorInvocation <$> minvoc,
  Just $ newlineSep (writeBlockStatement <$> stmts)]

writeConstructorDeclaration :: Java.ConstructorDeclaration -> CT.Expr
writeConstructorDeclaration (Java.ConstructorDeclaration mods cons mthrows body) = spaceSep $ Y.catMaybes [
  if L.null mods then Nothing else Just $ spaceSep (writeConstructorModifier <$> mods),
  Just $ writeConstructorDeclarator cons,
  writeThrows <$> mthrows,
  Just $ writeConstructorBody body]

writeConstructorDeclarator :: Java.ConstructorDeclarator -> CT.Expr
writeConstructorDeclarator (Java.ConstructorDeclarator tparams name mrecparam fparams) = spaceSep $ Y.catMaybes [
  if L.null tparams then Nothing else Just $ angleBracesList inlineStyle (writeTypeParameter <$> tparams),
  Just $ writeSimpleTypeName name,
  writeReceiverParameter <$> mrecparam,
  Just $ parenList False (writeFormalParameter <$> fparams)]

writeConstructorModifier :: Java.ConstructorModifier -> CT.Expr
writeConstructorModifier m = case m of
  Java.ConstructorModifierAnnotation ann -> writeAnnotation ann
  Java.ConstructorModifierPublic -> cst "public"
  Java.ConstructorModifierProtected -> cst "protected"
  Java.ConstructorModifierPrivate -> cst "private"

writeContinueStatement :: Java.ContinueStatement -> CT.Expr
writeContinueStatement _ = cst "TODO:ContinueStatement"

writeDims :: Java.Dims -> CT.Expr
writeDims (Java.Dims anns) = noSep (write <$> anns)
  where
    write _ = cst "[]" -- Note: ignoring annotations on dimensions for now

writeDoStatement :: Java.DoStatement -> CT.Expr
writeDoStatement _ = cst "TODO:DoStatement"

writeElementValue :: Java.ElementValue -> CT.Expr
writeElementValue ev = case ev of
  Java.ElementValueConditionalExpression c -> writeConditionalExpression c
  Java.ElementValueElementValueArrayInitializer (Java.ElementValueArrayInitializer values) ->
    commaSep inlineStyle (writeElementValue <$> values)
  Java.ElementValueAnnotation ann -> writeAnnotation ann

writeElementValuePair :: Java.ElementValuePair -> CT.Expr
writeElementValuePair (Java.ElementValuePair k v) = infixWs "=" (writeIdentifier k) (writeElementValue v)

writeEmptyStatement :: Java.EmptyStatement -> CT.Expr
writeEmptyStatement _ = semi

writeEnumDeclaration :: Java.EnumDeclaration -> CT.Expr
writeEnumDeclaration _ = cst "TODO:EnumDeclaration"

writeEqualityExpression :: Java.EqualityExpression -> CT.Expr
writeEqualityExpression e = case e of
  Java.EqualityExpressionUnary r -> writeRelationalExpression r
  Java.EqualityExpressionEqual (Java.EqualityExpression_Binary lhs rhs) ->
    infixWs "==" (writeEqualityExpression lhs) (writeRelationalExpression rhs)
  Java.EqualityExpressionNotEqual (Java.EqualityExpression_Binary lhs rhs) ->
    infixWs "!=" (writeEqualityExpression lhs) (writeRelationalExpression rhs)

writeExclusiveOrExpression :: Java.ExclusiveOrExpression -> CT.Expr
writeExclusiveOrExpression (Java.ExclusiveOrExpression ands) = infixWsList "^" (writeAndExpression <$> ands)

writeExplicitConstructorInvocation :: Java.ExplicitConstructorInvocation -> CT.Expr
writeExplicitConstructorInvocation _ = cst "TODO:ExplicitConstructorInvocation"

writeExpression :: Java.Expression -> CT.Expr
writeExpression e = case e of
  Java.ExpressionLambda l -> writeLambdaExpression l
  Java.ExpressionAssignment a -> writeAssignmentExpression a

writeExpressionName :: Java.ExpressionName -> CT.Expr
writeExpressionName (Java.ExpressionName mqual id) = dotSep $ Y.catMaybes [
  writeAmbiguousName <$> mqual,
  Just $ writeIdentifier id]

writeExpressionStatement :: Java.ExpressionStatement -> CT.Expr
writeExpressionStatement (Java.ExpressionStatement stmt) = suffixSemi $ writeStatementExpression stmt

writeFieldAccess :: Java.FieldAccess -> CT.Expr
writeFieldAccess (Java.FieldAccess qual id) = dotSep $ case qual of
  Java.FieldAccess_QualifierPrimary p -> [writePrimary p, writeIdentifier id]
  Java.FieldAccess_QualifierSuper -> [cst "super", writeIdentifier id]
  Java.FieldAccess_QualifierTyped tn -> [writeTypeName tn, cst "super", writeIdentifier id]

writeFieldDeclaration :: Java.FieldDeclaration -> CT.Expr
writeFieldDeclaration (Java.FieldDeclaration mods typ vars) = suffixSemi $ spaceSep $ Y.catMaybes [
    if L.null mods then Nothing else Just $ spaceSep (writeFieldModifier <$> mods),
    Just $ writeUnannType typ,
    Just $ commaSep inlineStyle (writeVariableDeclarator <$> vars)]

writeFieldModifier :: Java.FieldModifier -> CT.Expr
writeFieldModifier m = case m of
  Java.FieldModifierAnnotation ann -> writeAnnotation ann
  Java.FieldModifierPublic -> cst "public"
  Java.FieldModifierProtected -> cst "protected"
  Java.FieldModifierPrivate -> cst "private"
  Java.FieldModifierStatic -> cst "static"
  Java.FieldModifierFinal -> cst "final"
  Java.FieldModifierTransient -> cst "transient"
  Java.FieldModifierVolatile -> cst "volatile"

writeFloatingPointLiteral :: Java.FloatingPointLiteral -> CT.Expr
writeFloatingPointLiteral _ = cst "TODO:FloatingPointLiteral"

writeFloatingPointType :: Java.FloatingPointType -> CT.Expr
writeFloatingPointType _ = cst "TODO:FloatingPointType"

writeForStatement :: Java.ForStatement -> CT.Expr
writeForStatement _ = cst "TODO:ForStatement"

writeFormalParameter :: Java.FormalParameter -> CT.Expr
writeFormalParameter p = case p of
  Java.FormalParameterSimple s -> writeFormalParameter_Simple s
  Java.FormalParameterVariableArity v -> writeVariableArityParameter v

writeFormalParameter_Simple :: Java.FormalParameter_Simple -> CT.Expr
writeFormalParameter_Simple (Java.FormalParameter_Simple mods typ id) = spaceSep $ Y.catMaybes [
  if L.null mods then Nothing else Just $ spaceSep (writeVariableModifier <$> mods),
  Just $ writeUnannType typ,
  Just $ writeVariableDeclaratorId id]

writeIdentifier :: Java.Identifier -> CT.Expr
writeIdentifier (Java.Identifier s) = cst s

writeIfThenStatement :: Java.IfThenStatement -> CT.Expr
writeIfThenStatement (Java.IfThenStatement cond thn) = spaceSep [
  cst "if",
  parenList False [writeExpression cond],
  writeBlock (Java.Block [Java.BlockStatementStatement thn])]

writeIfThenElseStatement :: Java.IfThenElseStatement -> CT.Expr
writeIfThenElseStatement _ = cst "TODO:IfThenElseStatement"

writeImportDeclaration :: Java.ImportDeclaration -> CT.Expr
writeImportDeclaration imp = case imp of
  Java.ImportDeclarationSingleType d -> cst "TODO:ImportDeclarationSingleType"
  Java.ImportDeclarationTypeImportOnDemand d -> cst "TODO:ImportDeclarationTypeImportOnDemand"
  Java.ImportDeclarationSingleStaticImport d -> cst "TODO:ImportDeclarationSingleStaticImport"
  Java.ImportDeclarationStaticImportOnDemand d -> cst "TODO:ImportDeclarationStaticImportOnDemand"

writeInclusiveOrExpression :: Java.InclusiveOrExpression -> CT.Expr
writeInclusiveOrExpression (Java.InclusiveOrExpression ors)
  = infixWsList "|" (writeExclusiveOrExpression <$> ors)

writeInstanceInitializer :: Java.InstanceInitializer -> CT.Expr
writeInstanceInitializer _ = cst "TODO:InstanceInitializer"

writeIntegerLiteral :: Java.IntegerLiteral -> CT.Expr
writeIntegerLiteral (Java.IntegerLiteral i) = cst $ show i

writeIntegralType :: Java.IntegralType -> CT.Expr
writeIntegralType t = cst $ case t of
  Java.IntegralTypeByte -> "byte"
  Java.IntegralTypeShort -> "short"
  Java.IntegralTypeInt -> "int"
  Java.IntegralTypeLong -> "long"
  Java.IntegralTypeChar -> "char"

writeInterfaceBody :: Java.InterfaceBody -> CT.Expr
writeInterfaceBody (Java.InterfaceBody decls) = curlyBlock fullBlockStyle $ doubleNewlineSep
  (writeInterfaceMemberDeclaration <$> decls)

writeInterfaceDeclaration :: Java.InterfaceDeclaration -> CT.Expr
writeInterfaceDeclaration d = case d of
  Java.InterfaceDeclarationNormalInterface n -> writeNormalInterfaceDeclaration n
  Java.InterfaceDeclarationAnnotationType a -> writeAnnotationTypeDeclaration a

writeInterfaceMemberDeclaration :: Java.InterfaceMemberDeclaration -> CT.Expr
writeInterfaceMemberDeclaration d = case d of
  Java.InterfaceMemberDeclarationConstant c -> writeConstantDeclaration c
  Java.InterfaceMemberDeclarationInterfaceMethod im -> writeInterfaceMethodDeclaration im
  Java.InterfaceMemberDeclarationClass cd -> writeClassDeclaration cd
  Java.InterfaceMemberDeclarationInterface id -> writeInterfaceDeclaration id

writeInterfaceMethodDeclaration :: Java.InterfaceMethodDeclaration -> CT.Expr
writeInterfaceMethodDeclaration (Java.InterfaceMethodDeclaration mods header body) = spaceSep $ Y.catMaybes [
      if L.null mods then Nothing else Just $ spaceSep (writeInterfaceMethodModifier <$> mods),
      Just $ writeMethodHeader header,
      Just $ writeMethodBody body]

writeInterfaceMethodModifier :: Java.InterfaceMethodModifier -> CT.Expr
writeInterfaceMethodModifier m = case m of
  Java.InterfaceMethodModifierAnnotation a -> writeAnnotation a
  Java.InterfaceMethodModifierPublic -> cst "public"
  Java.InterfaceMethodModifierPrivate -> cst "private"
  Java.InterfaceMethodModifierAbstract -> cst "abstract"
  Java.InterfaceMethodModifierDefault -> cst "default"
  Java.InterfaceMethodModifierStatic -> cst "static"
  Java.InterfaceMethodModifierStrictfp -> cst "strictfp"

writeInterfaceModifier :: Java.InterfaceModifier -> CT.Expr
writeInterfaceModifier m = case m of
  Java.InterfaceModifierAnnotation a -> writeAnnotation a
  Java.InterfaceModifierPublic -> cst "public"
  Java.InterfaceModifierProtected -> cst "protected"
  Java.InterfaceModifierPrivate -> cst "private"
  Java.InterfaceModifierAbstract -> cst "abstract"
  Java.InterfaceModifierStatic -> cst "static"
  Java.InterfaceModifierStrictfb -> cst "strictfb"

writeInterfaceType :: Java.InterfaceType -> CT.Expr
writeInterfaceType (Java.InterfaceType ct) = writeClassType ct

writeLabeledStatement :: Java.LabeledStatement -> CT.Expr
writeLabeledStatement _ = cst "TODO:LabeledStatement"

writeLambdaBody :: Java.LambdaBody -> CT.Expr
writeLambdaBody b = case b of
  Java.LambdaBodyExpression e -> writeExpression e
  Java.LambdaBodyBlock b -> writeBlock b

writeLambdaExpression :: Java.LambdaExpression -> CT.Expr
writeLambdaExpression (Java.LambdaExpression params body) =
  infixWs "->" (writeLambdaParameters params) (writeLambdaBody body)

writeLambdaParameters :: Java.LambdaParameters -> CT.Expr
writeLambdaParameters p = case p of
  Java.LambdaParametersTuple l -> parenList False (writeLambdaParameters <$> l)
  Java.LambdaParametersSingle id -> writeIdentifier id

writeLeftHandSide :: Java.LeftHandSide -> CT.Expr
writeLeftHandSide lhs = case lhs of
  Java.LeftHandSideExpressionName en -> writeExpressionName en
  Java.LeftHandSideFieldAccess fa -> writeFieldAccess fa
  Java.LeftHandSideArrayAccess aa -> writeArrayAccess aa

writeLiteral :: Java.Literal -> CT.Expr
writeLiteral l = case l of
  Java.LiteralNull -> cst "null"
  Java.LiteralInteger il -> writeIntegerLiteral il
  Java.LiteralFloatingPoint fl -> writeFloatingPointLiteral fl
  Java.LiteralBoolean b -> cst $ if b then "true" else "false"
  Java.LiteralCharacter c -> writeCharacterLiteral c
  Java.LiteralString sl -> writeStringLiteral sl

writeLocalVariableDeclaration :: Java.LocalVariableDeclaration -> CT.Expr
writeLocalVariableDeclaration (Java.LocalVariableDeclaration mods t decls) = spaceSep $ Y.catMaybes [
  if L.null mods then Nothing else Just $ spaceSep (writeVariableModifier <$> mods),
  Just $ writeLocalVariableType t,
  Just $ commaSep inlineStyle (writeVariableDeclarator <$> decls)]

writeLocalVariableDeclarationStatement :: Java.LocalVariableDeclarationStatement -> CT.Expr
writeLocalVariableDeclarationStatement (Java.LocalVariableDeclarationStatement d) = suffixSemi $ writeLocalVariableDeclaration d

writeLocalVariableType :: Java.LocalVariableType -> CT.Expr
writeLocalVariableType t = case t of
  Java.LocalVariableTypeType ut -> writeUnannType ut
  Java.LocalVariableTypeVar -> cst "var"

writeMarkerAnnotation :: Java.MarkerAnnotation -> CT.Expr
writeMarkerAnnotation (Java.MarkerAnnotation tname) = prefixAt $ writeTypeName tname

writeMethodBody :: Java.MethodBody -> CT.Expr
writeMethodBody b = case b of
  Java.MethodBodyBlock block -> writeBlock block
  Java.MethodBodyNone -> semi

writeMethodDeclaration :: Java.MethodDeclaration -> CT.Expr
writeMethodDeclaration (Java.MethodDeclaration anns mods header body) = newlineSep $ Y.catMaybes [
    if L.null anns then Nothing else Just $ newlineSep (writeAnnotation <$> anns),
    Just headerAndBody]
  where
    headerAndBody = spaceSep $ Y.catMaybes [
      if L.null mods then Nothing else Just $ spaceSep (writeMethodModifier <$> mods),
      Just $ writeMethodHeader header,
      Just $ writeMethodBody body]

writeMethodDeclarator :: Java.MethodDeclarator -> CT.Expr
writeMethodDeclarator (Java.MethodDeclarator id rparam params) = noSep [
  writeIdentifier id,
  -- Note: ignoring receiver param for now
  parenList False (writeFormalParameter <$> params)]

writeMethodHeader :: Java.MethodHeader -> CT.Expr
writeMethodHeader (Java.MethodHeader params result decl mthrows) = spaceSep $ Y.catMaybes [
  if L.null params then Nothing else Just $ angleBracesList inlineStyle (writeTypeParameter <$> params),
  Just $ writeResult result,
  Just $ writeMethodDeclarator decl,
  writeThrows <$> mthrows]

writeMethodInvocation :: Java.MethodInvocation -> CT.Expr
writeMethodInvocation (Java.MethodInvocation header args) = noSep [headerSec, argSec]
  where
    argSec = parenList True (writeExpression <$> args)
    headerSec = case header of
      Java.MethodInvocation_HeaderSimple mname -> writeMethodName mname
      Java.MethodInvocation_HeaderComplex (Java.MethodInvocation_Complex var targs id) -> case var of
          Java.MethodInvocation_VariantType tname -> dotSep [writeTypeName tname, idSec]
          Java.MethodInvocation_VariantExpression en -> dotSep [writeExpressionName en, idSec]
          Java.MethodInvocation_VariantPrimary p -> dotSep [writePrimary p, idSec]
          Java.MethodInvocation_VariantSuper -> dotSep [super, idSec]
          Java.MethodInvocation_VariantTypeSuper tname -> dotSep [writeTypeName tname, super, idSec]
        where
          super = cst "super"
          idSec = noSep $ Y.catMaybes [
            if L.null targs then Nothing else Just $ angleBracesList inlineStyle (writeTypeArgument <$> targs),
            Just $ writeIdentifier id]

writeMethodModifier :: Java.MethodModifier -> CT.Expr
writeMethodModifier m = case m of
  Java.MethodModifierAnnotation ann -> writeAnnotation ann
  Java.MethodModifierPublic -> cst "public"
  Java.MethodModifierProtected -> cst "protected"
  Java.MethodModifierPrivate -> cst "private"
  Java.MethodModifierAbstract -> cst "abstract"
  Java.MethodModifierFinal -> cst "final"
  Java.MethodModifierSynchronized -> cst "synchronized"
  Java.MethodModifierNative -> cst "native"
  Java.MethodModifierStrictfb -> cst "strictfb"

writeMethodName :: Java.MethodName -> CT.Expr
writeMethodName (Java.MethodName id) = writeIdentifier id

writeMethodReference :: Java.MethodReference -> CT.Expr
writeMethodReference _ = cst "TODO:MethodReference"

writeMultiplicativeExpression :: Java.MultiplicativeExpression -> CT.Expr
writeMultiplicativeExpression e = case e of
  Java.MultiplicativeExpressionUnary u -> writeUnaryExpression u
  Java.MultiplicativeExpressionTimes (Java.MultiplicativeExpression_Binary lhs rhs) ->
    infixWs "*" (writeMultiplicativeExpression lhs) (writeUnaryExpression rhs)
  Java.MultiplicativeExpressionDivide (Java.MultiplicativeExpression_Binary lhs rhs) ->
    infixWs "/" (writeMultiplicativeExpression lhs) (writeUnaryExpression rhs)
  Java.MultiplicativeExpressionMod (Java.MultiplicativeExpression_Binary lhs rhs) ->
    infixWs "%" (writeMultiplicativeExpression lhs) (writeUnaryExpression rhs)

writeNormalAnnotation :: Java.NormalAnnotation -> CT.Expr
writeNormalAnnotation (Java.NormalAnnotation tname pairs) = prefixAt $ noSep [
  writeTypeName tname,
  commaSep inlineStyle (writeElementValuePair <$> pairs)]

writeNormalClassDeclaration :: Java.NormalClassDeclaration -> CT.Expr
writeNormalClassDeclaration (Java.NormalClassDeclaration mods id tparams msuperc superi body) =
    spaceSep $ Y.catMaybes [modSec, classSec, idSec, extendsSec, implementsSec, bodySec]
  where
    modSec = if L.null mods
      then Nothing
      else Just $ spaceSep (writeClassModifier <$> mods)
    classSec = Just $ cst "class"
    idSec = Just $ noSep $ Y.catMaybes [Just $ writeTypeIdentifier id, params]
      where
        params = if L.null tparams
          then Nothing
          else Just $ angleBracesList inlineStyle (writeTypeParameter <$> tparams)
    extendsSec = fmap (\c -> spaceSep [cst "extends", writeClassType c]) msuperc
    implementsSec = if L.null superi
      then Nothing
      else Just $ spaceSep [cst "implements", commaSep inlineStyle (writeInterfaceType <$> superi)]
    bodySec = Just $ writeClassBody body

writeNormalInterfaceDeclaration :: Java.NormalInterfaceDeclaration -> CT.Expr
writeNormalInterfaceDeclaration (Java.NormalInterfaceDeclaration mods id tparams extends body) =
    spaceSep $ Y.catMaybes [modSec, classSec, idSec, extendsSec, bodySec]
  where
    modSec = if L.null mods
      then Nothing
      else Just $ spaceSep (writeInterfaceModifier <$> mods)
    classSec = Just $ cst "interface"
    idSec = Just $ noSep $ Y.catMaybes [Just $ writeTypeIdentifier id, params]
      where
        params = if L.null tparams
          then Nothing
          else Just $ angleBracesList inlineStyle (writeTypeParameter <$> tparams)
    extendsSec = if L.null extends then Nothing else Just $
      spaceSep [cst "extends", commaSep inlineStyle (writeInterfaceType <$> extends)]
    bodySec = Just $ writeInterfaceBody body

writeNumericType :: Java.NumericType -> CT.Expr
writeNumericType nt = case nt of
  Java.NumericTypeIntegral it -> writeIntegralType it
  Java.NumericTypeFloatingPoint ft -> writeFloatingPointType ft

writePackageDeclaration :: Java.PackageDeclaration -> CT.Expr
writePackageDeclaration (Java.PackageDeclaration mods ids) = suffixSemi $ spaceSep $ Y.catMaybes [
    if L.null mods then Nothing else Just $ spaceSep (writePackageModifier <$> mods),
    Just $ spaceSep [cst "package", cst $ L.intercalate "." (Java.unIdentifier <$> ids)]]

writePackageName :: Java.PackageName -> CT.Expr
writePackageName (Java.PackageName ids) = dotSep (writeIdentifier <$> ids)

writePackageOrTypeName :: Java.PackageOrTypeName -> CT.Expr
writePackageOrTypeName (Java.PackageOrTypeName ids) = dotSep (writeIdentifier <$> ids)

writePackageModifier :: Java.PackageModifier -> CT.Expr
writePackageModifier (Java.PackageModifier ann) = writeAnnotation ann

writePostDecrementExpression :: Java.PostDecrementExpression -> CT.Expr
writePostDecrementExpression _ = cst "TODO:PostDecrementExpression"

writePostIncrementExpression :: Java.PostIncrementExpression -> CT.Expr
writePostIncrementExpression _ = cst "TODO:PostIncrementExpression"

writePostfixExpression :: Java.PostfixExpression -> CT.Expr
writePostfixExpression e = case e of
  Java.PostfixExpressionPrimary p -> writePrimary p
  Java.PostfixExpressionName en -> writeExpressionName en
  Java.PostfixExpressionPostIncrement pi -> writePostIncrementExpression pi
  Java.PostfixExpressionPostDecrement pd -> writePostDecrementExpression pd

writePreDecrementExpression:: Java.PreDecrementExpression -> CT.Expr
writePreDecrementExpression _ = cst "TODO:PreDecrementExpression"

writePreIncrementExpression :: Java.PreIncrementExpression -> CT.Expr
writePreIncrementExpression _ = cst "TODO:PreIncrementExpression"

writePrimary :: Java.Primary -> CT.Expr
writePrimary p = case p of
  Java.PrimaryNoNewArray n -> writePrimaryNoNewArray n
  Java.PrimaryArrayCreation a -> writeArrayCreationExpression a

writePrimaryNoNewArray :: Java.PrimaryNoNewArray -> CT.Expr
writePrimaryNoNewArray p = case p of
  Java.PrimaryNoNewArrayLiteral l -> writeLiteral l
  Java.PrimaryNoNewArrayClassLiteral cl -> writeClassLiteral cl
  Java.PrimaryNoNewArrayThis -> cst "this"
  Java.PrimaryNoNewArrayDotThis n -> dotSep [writeTypeName n, cst "this"]
  Java.PrimaryNoNewArrayParens e -> parenList False [writeExpression e]
  Java.PrimaryNoNewArrayClassInstance ci -> writeClassInstanceCreationExpression ci
  Java.PrimaryNoNewArrayFieldAccess fa -> writeFieldAccess fa
  Java.PrimaryNoNewArrayArrayAccess aa -> writeArrayAccess aa
  Java.PrimaryNoNewArrayMethodInvocation mi -> writeMethodInvocation mi
  Java.PrimaryNoNewArrayMethodReference mr -> writeMethodReference mr

writePrimitiveType :: Java.PrimitiveType -> CT.Expr
writePrimitiveType pt = case pt of
  Java.PrimitiveTypeNumeric nt -> writeNumericType nt
  Java.PrimitiveTypeBoolean -> cst "boolean"

writePrimitiveTypeWithAnnotations :: Java.PrimitiveTypeWithAnnotations -> CT.Expr
writePrimitiveTypeWithAnnotations (Java.PrimitiveTypeWithAnnotations pt anns) = spaceSep $ Y.catMaybes [
  if L.null anns then Nothing else Just $ spaceSep (writeAnnotation <$> anns),
  Just $ writePrimitiveType pt]

writeReceiverParameter :: Java.ReceiverParameter -> CT.Expr
writeReceiverParameter _ = cst "TODO:ReceiverParameter"

writeReferenceType :: Java.ReferenceType -> CT.Expr
writeReferenceType rt = case rt of
  Java.ReferenceTypeClassOrInterface cit -> writeClassOrInterfaceType cit
  Java.ReferenceTypeVariable v -> writeVariableType v
  Java.ReferenceTypeArray at -> writeArrayType at

writeRelationalExpression :: Java.RelationalExpression -> CT.Expr
writeRelationalExpression e = case e of
  Java.RelationalExpressionSimple s -> writeShiftExpression s
  Java.RelationalExpressionLessThan lt -> writeRelationalExpression_LessThan lt
  Java.RelationalExpressionGreaterThan gt -> writeRelationalExpression_GreaterThan gt
  Java.RelationalExpressionLessThanEqual lte -> writeRelationalExpression_LessThanEqual lte
  Java.RelationalExpressionGreaterThanEqual gte -> writeRelationalExpression_GreaterThanEqual gte
  Java.RelationalExpressionInstanceof i -> writeRelationalExpression_InstanceOf i

writeRelationalExpression_GreaterThan :: Java.RelationalExpression_GreaterThan -> CT.Expr
writeRelationalExpression_GreaterThan _ = cst "TODO:RelationalExpression_GreaterThan"

writeRelationalExpression_GreaterThanEqual :: Java.RelationalExpression_GreaterThanEqual -> CT.Expr
writeRelationalExpression_GreaterThanEqual _ = cst "TODO:RelationalExpression_GreaterThanEqual"

writeRelationalExpression_InstanceOf :: Java.RelationalExpression_InstanceOf -> CT.Expr
writeRelationalExpression_InstanceOf (Java.RelationalExpression_InstanceOf lhs rhs) =
  infixWs "instanceof" (writeRelationalExpression lhs) (writeReferenceType rhs)

writeRelationalExpression_LessThan :: Java.RelationalExpression_LessThan -> CT.Expr
writeRelationalExpression_LessThan _ = cst "TODO:RelationalExpression_LessThan"

writeRelationalExpression_LessThanEqual :: Java.RelationalExpression_LessThanEqual -> CT.Expr
writeRelationalExpression_LessThanEqual _ = cst "TODO:RelationalExpression_LessThanEqual"

writeResult :: Java.Result -> CT.Expr
writeResult r = case r of
  Java.ResultType t -> writeUnannType t
  Java.ResultVoid -> cst "void"

writeReturnStatement :: Java.ReturnStatement -> CT.Expr
writeReturnStatement (Java.ReturnStatement mex) = suffixSemi $ spaceSep $ Y.catMaybes [
  Just $ cst "return",
  writeExpression <$> mex]

writeShiftExpression :: Java.ShiftExpression -> CT.Expr
writeShiftExpression e = case e of
  Java.ShiftExpressionUnary a -> writeAdditiveExpression a
  Java.ShiftExpressionShiftLeft (Java.ShiftExpression_Binary lhs rhs) ->
    infixWs "<<" (writeShiftExpression lhs) (writeAdditiveExpression rhs)
  Java.ShiftExpressionShiftRight (Java.ShiftExpression_Binary lhs rhs) ->
    infixWs ">>" (writeShiftExpression lhs) (writeAdditiveExpression rhs)
  Java.ShiftExpressionShiftRightZeroFill (Java.ShiftExpression_Binary lhs rhs) ->
    infixWs ">>>" (writeShiftExpression lhs) (writeAdditiveExpression rhs)

writeSimpleTypeName :: Java.SimpleTypeName -> CT.Expr
writeSimpleTypeName (Java.SimpleTypeName tid) = writeTypeIdentifier tid

writeSingleElementAnnotation :: Java.SingleElementAnnotation -> CT.Expr
writeSingleElementAnnotation (Java.SingleElementAnnotation tname mv) = case mv of
  Nothing -> writeMarkerAnnotation (Java.MarkerAnnotation tname)
  Just v -> prefixAt $ noSep [writeTypeName tname, parenList False [writeElementValue v]]

writeStatement :: Java.Statement -> CT.Expr
writeStatement s = case s of
  Java.StatementWithoutTrailing s -> writeStatementWithoutTrailingSubstatement s
  Java.StatementLabeled l -> writeLabeledStatement l
  Java.StatementIfThen it -> writeIfThenStatement it
  Java.StatementIfThenElse ite -> writeIfThenElseStatement ite
  Java.StatementWhile w -> writeWhileStatement w
  Java.StatementFor f -> writeForStatement f

writeStatementExpression :: Java.StatementExpression -> CT.Expr
writeStatementExpression e = case e of
  Java.StatementExpressionAssignment ass -> writeAssignment ass
  Java.StatementExpressionPreIncrement pi -> writePreIncrementExpression pi
  Java.StatementExpressionPreDecrement pd -> writePreDecrementExpression pd
  Java.StatementExpressionPostIncrement pi -> writePostIncrementExpression pi
  Java.StatementExpressionPostDecrement pd -> writePostDecrementExpression pd
  Java.StatementExpressionMethodInvocation m -> writeMethodInvocation m
  Java.StatementExpressionClassInstanceCreation cic -> writeClassInstanceCreationExpression cic

writeStatementWithoutTrailingSubstatement :: Java.StatementWithoutTrailingSubstatement -> CT.Expr
writeStatementWithoutTrailingSubstatement s = case s of
  Java.StatementWithoutTrailingSubstatementBlock b -> writeBlock b
  Java.StatementWithoutTrailingSubstatementEmpty e -> writeEmptyStatement e
  Java.StatementWithoutTrailingSubstatementExpression e -> writeExpressionStatement e
  Java.StatementWithoutTrailingSubstatementAssert a -> writeAssertStatement a
  Java.StatementWithoutTrailingSubstatementSwitch s -> writeSwitchStatement s
  Java.StatementWithoutTrailingSubstatementDo d -> writeDoStatement d
  Java.StatementWithoutTrailingSubstatementBreak b -> writeBreakStatement b
  Java.StatementWithoutTrailingSubstatementContinue c -> writeContinueStatement c
  Java.StatementWithoutTrailingSubstatementReturn r -> writeReturnStatement r
  Java.StatementWithoutTrailingSubstatementSynchronized s -> writeSynchronizedStatement s
  Java.StatementWithoutTrailingSubstatementThrow t -> writeThrowStatement t
  Java.StatementWithoutTrailingSubstatementTry t -> writeTryStatement t

writeStaticInitializer :: Java.StaticInitializer -> CT.Expr
writeStaticInitializer _ = cst "TODO:StaticInitializer"

writeStringLiteral :: Java.StringLiteral -> CT.Expr
writeStringLiteral (Java.StringLiteral s) = cst $ show s

writeSwitchStatement :: Java.SwitchStatement -> CT.Expr
writeSwitchStatement _ = cst "TODO:SwitchStatement"

writeSynchronizedStatement :: Java.SynchronizedStatement -> CT.Expr
writeSynchronizedStatement _ = cst "TODO:SynchronizedStatement"

writeThrowStatement :: Java.ThrowStatement -> CT.Expr
writeThrowStatement (Java.ThrowStatement ex) = suffixSemi $ spaceSep [cst "throw", writeExpression ex]

writeThrows :: Java.Throws -> CT.Expr
writeThrows _ = cst "TODO:Throws"

writeTryStatement :: Java.TryStatement -> CT.Expr
writeTryStatement _ = cst "TODO:TryStatement"

writeType :: Java.Type -> CT.Expr
writeType t = case t of
  Java.TypePrimitive pt -> writePrimitiveTypeWithAnnotations pt
  Java.TypeReference rt -> writeReferenceType rt

writeTypeArgument :: Java.TypeArgument -> CT.Expr
writeTypeArgument a = case a of
  Java.TypeArgumentReference rt -> writeReferenceType rt
  Java.TypeArgumentWildcard w -> writeWildcard w

writeTypeArgumentsOrDiamond :: Java.TypeArgumentsOrDiamond -> CT.Expr
writeTypeArgumentsOrDiamond targs = case targs of
  Java.TypeArgumentsOrDiamondArguments args -> angleBracesList inlineStyle (writeTypeArgument <$> args)
  Java.TypeArgumentsOrDiamondDiamond -> cst "<>"

writeTypeBound :: Java.TypeBound -> CT.Expr
writeTypeBound _ = cst "TODO:TypeBound"

writeTypeDeclaration :: Java.TypeDeclaration -> CT.Expr
writeTypeDeclaration d = case d of
  Java.TypeDeclarationClass d -> writeClassDeclaration d
  Java.TypeDeclarationInterface d -> writeInterfaceDeclaration d
  Java.TypeDeclarationNone -> semi

writeTypeDeclarationWithComments :: Java.TypeDeclarationWithComments -> CT.Expr
writeTypeDeclarationWithComments (Java.TypeDeclarationWithComments d mc) = withComments mc $ writeTypeDeclaration d

writeTypeIdentifier :: Java.TypeIdentifier -> CT.Expr
writeTypeIdentifier (Java.TypeIdentifier id) = writeIdentifier id

writeTypeName :: Java.TypeName -> CT.Expr
writeTypeName (Java.TypeName id mqual) = dotSep $ Y.catMaybes [
  writePackageOrTypeName <$> mqual,
  Just $ writeTypeIdentifier id]

writeTypeParameter :: Java.TypeParameter -> CT.Expr
writeTypeParameter (Java.TypeParameter mods id bound) = spaceSep $ Y.catMaybes [
  if L.null mods then Nothing else Just $ spaceSep (writeTypeParameterModifier <$> mods),
  Just $ writeTypeIdentifier id,
  fmap (\b -> spaceSep [cst "extends", writeTypeBound b]) bound]

writeTypeParameterModifier :: Java.TypeParameterModifier -> CT.Expr
writeTypeParameterModifier (Java.TypeParameterModifier ann) = writeAnnotation ann

writeVariableType :: Java.TypeVariable -> CT.Expr
writeVariableType (Java.TypeVariable anns id) = spaceSep $ Y.catMaybes [
  if L.null anns then Nothing else Just $ spaceSep (writeAnnotation <$> anns),
  Just $ writeTypeIdentifier id]

writeUnannType :: Java.UnannType -> CT.Expr
writeUnannType (Java.UnannType t) = writeType t

writeUnaryExpression :: Java.UnaryExpression -> CT.Expr
writeUnaryExpression e = case e of
  Java.UnaryExpressionPreIncrement pi -> writePreIncrementExpression pi
  Java.UnaryExpressionPreDecrement pd -> writePreDecrementExpression pd
  Java.UnaryExpressionPlus p -> spaceSep [cst "+", writeUnaryExpression p]
  Java.UnaryExpressionMinus m -> spaceSep [cst "-", writeUnaryExpression m]
  Java.UnaryExpressionOther o -> writeUnaryExpressionNotPlusMinus o

writeUnaryExpressionNotPlusMinus :: Java.UnaryExpressionNotPlusMinus -> CT.Expr
writeUnaryExpressionNotPlusMinus e = case e of
  Java.UnaryExpressionNotPlusMinusPostfix p -> writePostfixExpression p
  Java.UnaryExpressionNotPlusMinusTilde u -> spaceSep [cst "~", writeUnaryExpression u]
  Java.UnaryExpressionNotPlusMinusNot u -> noSep [cst "!", writeUnaryExpression u]
  Java.UnaryExpressionNotPlusMinusCast c -> writeCastExpression c

writeUnqualifiedClassInstanceCreationExpression  :: Java.UnqualifiedClassInstanceCreationExpression -> CT.Expr
writeUnqualifiedClassInstanceCreationExpression (Java.UnqualifiedClassInstanceCreationExpression targs cit args mbody)
  = spaceSep $ Y.catMaybes [
    Just $ cst "new",
    if L.null targs then Nothing else Just $ angleBracesList inlineStyle (writeTypeArgument <$> targs),
    Just $ noSep [writeClassOrInterfaceTypeToInstantiate cit, parenList False (writeExpression <$> args)],
    writeClassBody <$> mbody]

writeVariableArityParameter :: Java.VariableArityParameter -> CT.Expr
writeVariableArityParameter _ = cst "TODO:VariableArityParameter"

writeVariableDeclarator :: Java.VariableDeclarator -> CT.Expr
writeVariableDeclarator (Java.VariableDeclarator id minit) =
    Y.maybe idSec (infixWs "=" idSec . writeVariableInitializer) minit
  where
    idSec = writeVariableDeclaratorId id

writeVariableDeclaratorId :: Java.VariableDeclaratorId -> CT.Expr
writeVariableDeclaratorId (Java.VariableDeclaratorId id mdims) = noSep $ Y.catMaybes [
  Just $ writeIdentifier id,
  writeDims <$> mdims]

writeVariableInitializer :: Java.VariableInitializer -> CT.Expr
writeVariableInitializer i = case i of
  Java.VariableInitializerExpression e -> writeExpression e
  Java.VariableInitializerArrayInitializer ai -> writeArrayInitializer ai

writeVariableModifier :: Java.VariableModifier -> CT.Expr
writeVariableModifier m = case m of
  Java.VariableModifierAnnotation ann -> writeAnnotation ann
  Java.VariableModifierFinal -> cst "final"

writeWhileStatement :: Java.WhileStatement -> CT.Expr
writeWhileStatement _ = cst "TODO:WhileStatement"

writeWildcard :: Java.Wildcard -> CT.Expr
writeWildcard (Java.Wildcard anns mbounds) = spaceSep $ Y.catMaybes [
  if L.null anns then Nothing else Just $ commaSep inlineStyle (writeAnnotation <$> anns),
  Just $ cst "*",
  writeWildcardBounds <$> mbounds]

writeWildcardBounds :: Java.WildcardBounds -> CT.Expr
writeWildcardBounds b = case b of
  Java.WildcardBoundsExtends rt -> spaceSep [cst "extends", writeReferenceType rt]
  Java.WildcardBoundsSuper rt -> spaceSep [cst "super", writeReferenceType rt]

prefixAt :: CT.Expr -> CT.Expr
prefixAt e = noSep [cst "@", e]

semi :: CT.Expr
semi = cst ";"

suffixSemi :: CT.Expr -> CT.Expr
suffixSemi e = noSep [e, semi]