module Hydra.Langs.Java.Utils where

import Hydra.Kernel
import Hydra.Langs.Java.Language
import Hydra.Langs.Java.Names
import qualified Hydra.Langs.Java.Syntax as Java
import qualified Hydra.Lib.Strings as Strings

import qualified Data.List as L
import qualified Data.Map as M
import qualified Data.Set as S
import qualified Data.Maybe as Y


type PackageMap = M.Map Namespace Java.PackageName

data Aliases = Aliases {
  Aliases -> Namespace
aliasesCurrentNamespace :: Namespace,
  Aliases -> PackageMap
aliasesPackages :: PackageMap,
  Aliases -> Set Name
aliasesRecursiveVars :: S.Set Name } deriving Int -> Aliases -> ShowS
[Aliases] -> ShowS
Aliases -> String
(Int -> Aliases -> ShowS)
-> (Aliases -> String) -> ([Aliases] -> ShowS) -> Show Aliases
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Aliases -> ShowS
showsPrec :: Int -> Aliases -> ShowS
$cshow :: Aliases -> String
show :: Aliases -> String
$cshowList :: [Aliases] -> ShowS
showList :: [Aliases] -> ShowS
Show

addExpressions :: [Java.MultiplicativeExpression] -> Java.AdditiveExpression
addExpressions :: [MultiplicativeExpression] -> AdditiveExpression
addExpressions [MultiplicativeExpression]
exprs = (AdditiveExpression
 -> MultiplicativeExpression -> AdditiveExpression)
-> AdditiveExpression
-> [MultiplicativeExpression]
-> AdditiveExpression
forall b a. (b -> a -> b) -> b -> [a] -> b
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
L.foldl AdditiveExpression
-> MultiplicativeExpression -> AdditiveExpression
add (MultiplicativeExpression -> AdditiveExpression
Java.AdditiveExpressionUnary (MultiplicativeExpression -> AdditiveExpression)
-> MultiplicativeExpression -> AdditiveExpression
forall a b. (a -> b) -> a -> b
$ [MultiplicativeExpression] -> MultiplicativeExpression
forall a. HasCallStack => [a] -> a
L.head [MultiplicativeExpression]
exprs) ([MultiplicativeExpression] -> AdditiveExpression)
-> [MultiplicativeExpression] -> AdditiveExpression
forall a b. (a -> b) -> a -> b
$ [MultiplicativeExpression] -> [MultiplicativeExpression]
forall a. HasCallStack => [a] -> [a]
L.tail [MultiplicativeExpression]
exprs
  where
    add :: AdditiveExpression
-> MultiplicativeExpression -> AdditiveExpression
add AdditiveExpression
ae MultiplicativeExpression
me = AdditiveExpression_Binary -> AdditiveExpression
Java.AdditiveExpressionPlus (AdditiveExpression_Binary -> AdditiveExpression)
-> AdditiveExpression_Binary -> AdditiveExpression
forall a b. (a -> b) -> a -> b
$ AdditiveExpression
-> MultiplicativeExpression -> AdditiveExpression_Binary
Java.AdditiveExpression_Binary AdditiveExpression
ae MultiplicativeExpression
me

addJavaTypeParameter :: Java.ReferenceType -> Java.Type -> Flow (Graph) Java.Type
addJavaTypeParameter :: ReferenceType -> Type -> Flow Graph Type
addJavaTypeParameter ReferenceType
rt Type
t = case Type
t of
  Java.TypeReference ReferenceType
rt1 -> case ReferenceType
rt1 of
    Java.ReferenceTypeClassOrInterface ClassOrInterfaceType
cit -> case ClassOrInterfaceType
cit of
      Java.ClassOrInterfaceTypeClass (Java.ClassType [Annotation]
anns ClassTypeQualifier
qual TypeIdentifier
id [TypeArgument]
args) -> Type -> Flow Graph Type
forall a. a -> Flow Graph a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Type -> Flow Graph Type) -> Type -> Flow Graph Type
forall a b. (a -> b) -> a -> b
$
        ReferenceType -> Type
Java.TypeReference (ReferenceType -> Type) -> ReferenceType -> Type
forall a b. (a -> b) -> a -> b
$ ClassOrInterfaceType -> ReferenceType
Java.ReferenceTypeClassOrInterface (ClassOrInterfaceType -> ReferenceType)
-> ClassOrInterfaceType -> ReferenceType
forall a b. (a -> b) -> a -> b
$
          ClassType -> ClassOrInterfaceType
Java.ClassOrInterfaceTypeClass (ClassType -> ClassOrInterfaceType)
-> ClassType -> ClassOrInterfaceType
forall a b. (a -> b) -> a -> b
$ [Annotation]
-> ClassTypeQualifier
-> TypeIdentifier
-> [TypeArgument]
-> ClassType
Java.ClassType [Annotation]
anns ClassTypeQualifier
qual TypeIdentifier
id ([TypeArgument]
args [TypeArgument] -> [TypeArgument] -> [TypeArgument]
forall a. [a] -> [a] -> [a]
++ [ReferenceType -> TypeArgument
Java.TypeArgumentReference ReferenceType
rt])
      ClassOrInterfaceType
_ -> String -> Flow Graph Type
forall a. String -> Flow Graph a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> Flow Graph Type) -> String -> Flow Graph Type
forall a b. (a -> b) -> a -> b
$ String
"expected a Java class type. Found: " String -> ShowS
forall a. [a] -> [a] -> [a]
++ ClassOrInterfaceType -> String
forall a. Show a => a -> String
show ClassOrInterfaceType
cit
    Java.ReferenceTypeVariable TypeVariable
tv -> Type -> Flow Graph Type
forall a. a -> Flow Graph a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Type -> Flow Graph Type) -> Type -> Flow Graph Type
forall a b. (a -> b) -> a -> b
$ TypeVariable -> Type
javaTypeVariableToType TypeVariable
tv
    ReferenceType
_ -> String -> Flow Graph Type
forall a. String -> Flow Graph a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> Flow Graph Type) -> String -> Flow Graph Type
forall a b. (a -> b) -> a -> b
$ String
"expected a Java class or interface type, or a variable. Found: " String -> ShowS
forall a. [a] -> [a] -> [a]
++ ReferenceType -> String
forall a. Show a => a -> String
show ReferenceType
rt
  Type
_ -> String -> Flow Graph Type
forall a. String -> Flow Graph a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> Flow Graph Type) -> String -> Flow Graph Type
forall a b. (a -> b) -> a -> b
$ String
"expected a reference type. Found: " String -> ShowS
forall a. [a] -> [a] -> [a]
++ Type -> String
forall a. Show a => a -> String
show Type
t

fieldExpression :: Java.Identifier -> Java.Identifier -> Java.ExpressionName
fieldExpression :: Identifier -> Identifier -> ExpressionName
fieldExpression Identifier
varId Identifier
fieldId = Maybe AmbiguousName -> Identifier -> ExpressionName
Java.ExpressionName (AmbiguousName -> Maybe AmbiguousName
forall a. a -> Maybe a
Just (AmbiguousName -> Maybe AmbiguousName)
-> AmbiguousName -> Maybe AmbiguousName
forall a b. (a -> b) -> a -> b
$ [Identifier] -> AmbiguousName
Java.AmbiguousName [Identifier
varId]) Identifier
fieldId

fieldNameToJavaExpression :: Name -> Java.Expression
fieldNameToJavaExpression :: Name -> Expression
fieldNameToJavaExpression Name
fname = PostfixExpression -> Expression
javaPostfixExpressionToJavaExpression (PostfixExpression -> Expression)
-> PostfixExpression -> Expression
forall a b. (a -> b) -> a -> b
$
  ExpressionName -> PostfixExpression
Java.PostfixExpressionName (ExpressionName -> PostfixExpression)
-> ExpressionName -> PostfixExpression
forall a b. (a -> b) -> a -> b
$ Maybe AmbiguousName -> Identifier -> ExpressionName
Java.ExpressionName Maybe AmbiguousName
forall a. Maybe a
Nothing (Name -> Identifier
fieldNameToJavaIdentifier Name
fname)

fieldNameToJavaIdentifier :: Name -> Java.Identifier
fieldNameToJavaIdentifier :: Name -> Identifier
fieldNameToJavaIdentifier (Name String
name) = String -> Identifier
javaIdentifier String
name

fieldNameToJavaVariableDeclarator :: Name -> Java.VariableDeclarator
fieldNameToJavaVariableDeclarator :: Name -> VariableDeclarator
fieldNameToJavaVariableDeclarator (Name String
n) = Identifier -> Maybe VariableInitializer -> VariableDeclarator
javaVariableDeclarator (String -> Identifier
javaIdentifier String
n) Maybe VariableInitializer
forall a. Maybe a
Nothing

fieldNameToJavaVariableDeclaratorId :: Name -> Java.VariableDeclaratorId
fieldNameToJavaVariableDeclaratorId :: Name -> VariableDeclaratorId
fieldNameToJavaVariableDeclaratorId (Name String
n) = Identifier -> VariableDeclaratorId
javaVariableDeclaratorId (Identifier -> VariableDeclaratorId)
-> Identifier -> VariableDeclaratorId
forall a b. (a -> b) -> a -> b
$ String -> Identifier
javaIdentifier String
n

importAliasesForModule :: Module -> Aliases
importAliasesForModule :: Module -> Aliases
importAliasesForModule Module
mod = Namespace -> PackageMap -> Set Name -> Aliases
Aliases (Module -> Namespace
moduleNamespace Module
mod) PackageMap
forall k a. Map k a
M.empty Set Name
forall a. Set a
S.empty

interfaceMethodDeclaration :: [Java.InterfaceMethodModifier] -> [Java.TypeParameter] -> String -> [Java.FormalParameter]
   -> Java.Result -> Maybe [Java.BlockStatement] -> Java.InterfaceMemberDeclaration
interfaceMethodDeclaration :: [InterfaceMethodModifier]
-> [TypeParameter]
-> String
-> [FormalParameter]
-> Result
-> Maybe [BlockStatement]
-> InterfaceMemberDeclaration
interfaceMethodDeclaration [InterfaceMethodModifier]
mods [TypeParameter]
tparams String
methodName [FormalParameter]
params Result
result Maybe [BlockStatement]
stmts = InterfaceMethodDeclaration -> InterfaceMemberDeclaration
Java.InterfaceMemberDeclarationInterfaceMethod (InterfaceMethodDeclaration -> InterfaceMemberDeclaration)
-> InterfaceMethodDeclaration -> InterfaceMemberDeclaration
forall a b. (a -> b) -> a -> b
$
    [InterfaceMethodModifier]
-> MethodHeader -> MethodBody -> InterfaceMethodDeclaration
Java.InterfaceMethodDeclaration [InterfaceMethodModifier]
mods MethodHeader
header MethodBody
body
  where
    header :: MethodHeader
header = [TypeParameter]
-> String -> [FormalParameter] -> Result -> MethodHeader
javaMethodHeader [TypeParameter]
tparams String
methodName [FormalParameter]
params Result
result
    body :: MethodBody
body = Maybe [BlockStatement] -> MethodBody
javaMethodBody Maybe [BlockStatement]
stmts

isEscaped :: String -> Bool
isEscaped :: String -> Bool
isEscaped String
s = String -> Char
forall a. HasCallStack => [a] -> a
L.head String
s Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'$'

javaAdditiveExpressionToJavaExpression :: Java.AdditiveExpression -> Java.Expression
javaAdditiveExpressionToJavaExpression :: AdditiveExpression -> Expression
javaAdditiveExpressionToJavaExpression = RelationalExpression -> Expression
javaRelationalExpressionToJavaExpression (RelationalExpression -> Expression)
-> (AdditiveExpression -> RelationalExpression)
-> AdditiveExpression
-> Expression
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
  ShiftExpression -> RelationalExpression
Java.RelationalExpressionSimple (ShiftExpression -> RelationalExpression)
-> (AdditiveExpression -> ShiftExpression)
-> AdditiveExpression
-> RelationalExpression
forall b c a. (b -> c) -> (a -> b) -> a -> c
. AdditiveExpression -> ShiftExpression
Java.ShiftExpressionUnary

javaAssignmentStatement :: Java.LeftHandSide -> Java.Expression -> Java.Statement
javaAssignmentStatement :: LeftHandSide -> Expression -> Statement
javaAssignmentStatement LeftHandSide
lhs Expression
rhs = StatementWithoutTrailingSubstatement -> Statement
Java.StatementWithoutTrailing (StatementWithoutTrailingSubstatement -> Statement)
-> StatementWithoutTrailingSubstatement -> Statement
forall a b. (a -> b) -> a -> b
$ ExpressionStatement -> StatementWithoutTrailingSubstatement
Java.StatementWithoutTrailingSubstatementExpression (ExpressionStatement -> StatementWithoutTrailingSubstatement)
-> ExpressionStatement -> StatementWithoutTrailingSubstatement
forall a b. (a -> b) -> a -> b
$
    StatementExpression -> ExpressionStatement
Java.ExpressionStatement (StatementExpression -> ExpressionStatement)
-> StatementExpression -> ExpressionStatement
forall a b. (a -> b) -> a -> b
$ Assignment -> StatementExpression
Java.StatementExpressionAssignment Assignment
ass
  where
    ass :: Assignment
ass = LeftHandSide -> AssignmentOperator -> Expression -> Assignment
Java.Assignment LeftHandSide
lhs AssignmentOperator
Java.AssignmentOperatorSimple Expression
rhs

javaBoolean :: Bool -> Java.Literal
javaBoolean :: Bool -> Literal
javaBoolean = Bool -> Literal
Java.LiteralBoolean

javaBooleanExpression :: Bool -> Java.Expression
javaBooleanExpression :: Bool -> Expression
javaBooleanExpression = Primary -> Expression
javaPrimaryToJavaExpression (Primary -> Expression) -> (Bool -> Primary) -> Bool -> Expression
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Literal -> Primary
javaLiteralToJavaPrimary (Literal -> Primary) -> (Bool -> Literal) -> Bool -> Primary
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Literal
javaBoolean

javaBooleanType :: Java.Type
javaBooleanType :: Type
javaBooleanType = PrimitiveType -> Type
javaPrimitiveTypeToJavaType PrimitiveType
Java.PrimitiveTypeBoolean

javaCastExpression :: Java.ReferenceType -> Java.UnaryExpression -> Java.CastExpression
javaCastExpression :: ReferenceType -> UnaryExpression -> CastExpression
javaCastExpression ReferenceType
rt UnaryExpression
expr = CastExpression_NotPlusMinus -> CastExpression
Java.CastExpressionNotPlusMinus (CastExpression_NotPlusMinus -> CastExpression)
-> CastExpression_NotPlusMinus -> CastExpression
forall a b. (a -> b) -> a -> b
$ CastExpression_RefAndBounds
-> UnaryExpression -> CastExpression_NotPlusMinus
Java.CastExpression_NotPlusMinus CastExpression_RefAndBounds
rb UnaryExpression
expr
  where
    rb :: CastExpression_RefAndBounds
rb = ReferenceType -> [AdditionalBound] -> CastExpression_RefAndBounds
Java.CastExpression_RefAndBounds ReferenceType
rt []

javaCastExpressionToJavaExpression :: Java.CastExpression -> Java.Expression
javaCastExpressionToJavaExpression :: CastExpression -> Expression
javaCastExpressionToJavaExpression = UnaryExpression -> Expression
javaUnaryExpressionToJavaExpression (UnaryExpression -> Expression)
-> (CastExpression -> UnaryExpression)
-> CastExpression
-> Expression
forall b c a. (b -> c) -> (a -> b) -> a -> c
. UnaryExpressionNotPlusMinus -> UnaryExpression
Java.UnaryExpressionOther (UnaryExpressionNotPlusMinus -> UnaryExpression)
-> (CastExpression -> UnaryExpressionNotPlusMinus)
-> CastExpression
-> UnaryExpression
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
  CastExpression -> UnaryExpressionNotPlusMinus
Java.UnaryExpressionNotPlusMinusCast

javaClassDeclaration :: Aliases -> [Java.TypeParameter] -> Name -> [Java.ClassModifier]
   -> Maybe Name -> [Java.InterfaceType] -> [Java.ClassBodyDeclarationWithComments] -> Java.ClassDeclaration
javaClassDeclaration :: Aliases
-> [TypeParameter]
-> Name
-> [ClassModifier]
-> Maybe Name
-> [InterfaceType]
-> [ClassBodyDeclarationWithComments]
-> ClassDeclaration
javaClassDeclaration Aliases
aliases [TypeParameter]
tparams Name
elName [ClassModifier]
mods Maybe Name
supname [InterfaceType]
impls [ClassBodyDeclarationWithComments]
bodyDecls = NormalClassDeclaration -> ClassDeclaration
Java.ClassDeclarationNormal (NormalClassDeclaration -> ClassDeclaration)
-> NormalClassDeclaration -> ClassDeclaration
forall a b. (a -> b) -> a -> b
$ Java.NormalClassDeclaration {
  normalClassDeclarationModifiers :: [ClassModifier]
Java.normalClassDeclarationModifiers = [ClassModifier]
mods,
  normalClassDeclarationIdentifier :: TypeIdentifier
Java.normalClassDeclarationIdentifier = Name -> TypeIdentifier
javaDeclName Name
elName,
  normalClassDeclarationParameters :: [TypeParameter]
Java.normalClassDeclarationParameters = [TypeParameter]
tparams,
  normalClassDeclarationExtends :: Maybe ClassType
Java.normalClassDeclarationExtends = (Name -> ClassType) -> Maybe Name -> Maybe ClassType
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\Name
n -> Aliases
-> Bool -> [TypeArgument] -> Name -> Maybe String -> ClassType
nameToJavaClassType Aliases
aliases Bool
True [] Name
n Maybe String
forall a. Maybe a
Nothing) Maybe Name
supname,
  normalClassDeclarationImplements :: [InterfaceType]
Java.normalClassDeclarationImplements = [InterfaceType]
impls,
  normalClassDeclarationBody :: ClassBody
Java.normalClassDeclarationBody = [ClassBodyDeclarationWithComments] -> ClassBody
Java.ClassBody [ClassBodyDeclarationWithComments]
bodyDecls}

javaClassType :: [Java.ReferenceType] -> Maybe Java.PackageName -> String -> Java.ClassType
javaClassType :: [ReferenceType] -> Maybe PackageName -> String -> ClassType
javaClassType [ReferenceType]
args Maybe PackageName
pkg String
id = [Annotation]
-> ClassTypeQualifier
-> TypeIdentifier
-> [TypeArgument]
-> ClassType
Java.ClassType [] ClassTypeQualifier
qual (String -> TypeIdentifier
javaTypeIdentifier String
id) [TypeArgument]
targs
  where
    qual :: ClassTypeQualifier
qual = ClassTypeQualifier
-> (PackageName -> ClassTypeQualifier)
-> Maybe PackageName
-> ClassTypeQualifier
forall b a. b -> (a -> b) -> Maybe a -> b
maybe ClassTypeQualifier
Java.ClassTypeQualifierNone PackageName -> ClassTypeQualifier
Java.ClassTypeQualifierPackage Maybe PackageName
pkg
    targs :: [TypeArgument]
targs = ReferenceType -> TypeArgument
Java.TypeArgumentReference (ReferenceType -> TypeArgument)
-> [ReferenceType] -> [TypeArgument]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [ReferenceType]
args

javaClassTypeToJavaType :: Java.ClassType -> Java.Type
javaClassTypeToJavaType :: ClassType -> Type
javaClassTypeToJavaType = ReferenceType -> Type
Java.TypeReference (ReferenceType -> Type)
-> (ClassType -> ReferenceType) -> ClassType -> Type
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ClassOrInterfaceType -> ReferenceType
Java.ReferenceTypeClassOrInterface (ClassOrInterfaceType -> ReferenceType)
-> (ClassType -> ClassOrInterfaceType)
-> ClassType
-> ReferenceType
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ClassType -> ClassOrInterfaceType
Java.ClassOrInterfaceTypeClass

javaConditionalAndExpressionToJavaExpression :: Java.ConditionalAndExpression -> Java.Expression
javaConditionalAndExpressionToJavaExpression :: ConditionalAndExpression -> Expression
javaConditionalAndExpressionToJavaExpression ConditionalAndExpression
condAndEx = AssignmentExpression -> Expression
Java.ExpressionAssignment (AssignmentExpression -> Expression)
-> AssignmentExpression -> Expression
forall a b. (a -> b) -> a -> b
$
  ConditionalExpression -> AssignmentExpression
Java.AssignmentExpressionConditional (ConditionalExpression -> AssignmentExpression)
-> ConditionalExpression -> AssignmentExpression
forall a b. (a -> b) -> a -> b
$ ConditionalOrExpression -> ConditionalExpression
Java.ConditionalExpressionSimple (ConditionalOrExpression -> ConditionalExpression)
-> ConditionalOrExpression -> ConditionalExpression
forall a b. (a -> b) -> a -> b
$ [ConditionalAndExpression] -> ConditionalOrExpression
Java.ConditionalOrExpression [ConditionalAndExpression
condAndEx]

javaConstructorCall :: Java.ClassOrInterfaceTypeToInstantiate -> [Java.Expression] -> Maybe Java.ClassBody -> Java.Expression
javaConstructorCall :: ClassOrInterfaceTypeToInstantiate
-> [Expression] -> Maybe ClassBody -> Expression
javaConstructorCall ClassOrInterfaceTypeToInstantiate
ci [Expression]
args Maybe ClassBody
mbody = Primary -> Expression
javaPrimaryToJavaExpression (Primary -> Expression) -> Primary -> Expression
forall a b. (a -> b) -> a -> b
$
  PrimaryNoNewArray -> Primary
Java.PrimaryNoNewArray (PrimaryNoNewArray -> Primary) -> PrimaryNoNewArray -> Primary
forall a b. (a -> b) -> a -> b
$
  ClassInstanceCreationExpression -> PrimaryNoNewArray
Java.PrimaryNoNewArrayClassInstance (ClassInstanceCreationExpression -> PrimaryNoNewArray)
-> ClassInstanceCreationExpression -> PrimaryNoNewArray
forall a b. (a -> b) -> a -> b
$
  Maybe ClassInstanceCreationExpression_Qualifier
-> UnqualifiedClassInstanceCreationExpression
-> ClassInstanceCreationExpression
Java.ClassInstanceCreationExpression Maybe ClassInstanceCreationExpression_Qualifier
forall a. Maybe a
Nothing (UnqualifiedClassInstanceCreationExpression
 -> ClassInstanceCreationExpression)
-> UnqualifiedClassInstanceCreationExpression
-> ClassInstanceCreationExpression
forall a b. (a -> b) -> a -> b
$
  [TypeArgument]
-> ClassOrInterfaceTypeToInstantiate
-> [Expression]
-> Maybe ClassBody
-> UnqualifiedClassInstanceCreationExpression
Java.UnqualifiedClassInstanceCreationExpression [] ClassOrInterfaceTypeToInstantiate
ci [Expression]
args Maybe ClassBody
mbody

javaConstructorName :: Java.Identifier -> Maybe Java.TypeArgumentsOrDiamond -> Java.ClassOrInterfaceTypeToInstantiate
javaConstructorName :: Identifier
-> Maybe TypeArgumentsOrDiamond
-> ClassOrInterfaceTypeToInstantiate
javaConstructorName Identifier
id Maybe TypeArgumentsOrDiamond
targs = [AnnotatedIdentifier]
-> Maybe TypeArgumentsOrDiamond
-> ClassOrInterfaceTypeToInstantiate
Java.ClassOrInterfaceTypeToInstantiate [[Annotation] -> Identifier -> AnnotatedIdentifier
Java.AnnotatedIdentifier [] Identifier
id] Maybe TypeArgumentsOrDiamond
targs

javaDeclName :: Name -> Java.TypeIdentifier
javaDeclName :: Name -> TypeIdentifier
javaDeclName = Identifier -> TypeIdentifier
Java.TypeIdentifier (Identifier -> TypeIdentifier)
-> (Name -> Identifier) -> Name -> TypeIdentifier
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Name -> Identifier
javaVariableName

javaEmptyStatement :: Java.Statement
javaEmptyStatement :: Statement
javaEmptyStatement = StatementWithoutTrailingSubstatement -> Statement
Java.StatementWithoutTrailing (StatementWithoutTrailingSubstatement -> Statement)
-> StatementWithoutTrailingSubstatement -> Statement
forall a b. (a -> b) -> a -> b
$ EmptyStatement -> StatementWithoutTrailingSubstatement
Java.StatementWithoutTrailingSubstatementEmpty EmptyStatement
Java.EmptyStatement

javaEqualityExpressionToJavaExpression :: Java.EqualityExpression -> Java.Expression
javaEqualityExpressionToJavaExpression :: EqualityExpression -> Expression
javaEqualityExpressionToJavaExpression EqualityExpression
eqEx = ConditionalAndExpression -> Expression
javaConditionalAndExpressionToJavaExpression (ConditionalAndExpression -> Expression)
-> ConditionalAndExpression -> Expression
forall a b. (a -> b) -> a -> b
$
    [InclusiveOrExpression] -> ConditionalAndExpression
Java.ConditionalAndExpression [EqualityExpression -> InclusiveOrExpression
javaEqualityExpressionToJavaInclusiveOrExpression EqualityExpression
eqEx]

javaEqualityExpressionToJavaInclusiveOrExpression :: Java.EqualityExpression -> Java.InclusiveOrExpression
javaEqualityExpressionToJavaInclusiveOrExpression :: EqualityExpression -> InclusiveOrExpression
javaEqualityExpressionToJavaInclusiveOrExpression EqualityExpression
eq = [ExclusiveOrExpression] -> InclusiveOrExpression
Java.InclusiveOrExpression [
  [AndExpression] -> ExclusiveOrExpression
Java.ExclusiveOrExpression [[EqualityExpression] -> AndExpression
Java.AndExpression [EqualityExpression
eq]]]

javaEquals :: Java.EqualityExpression -> Java.RelationalExpression -> Java.EqualityExpression
javaEquals :: EqualityExpression -> RelationalExpression -> EqualityExpression
javaEquals EqualityExpression
lhs RelationalExpression
rhs = EqualityExpression_Binary -> EqualityExpression
Java.EqualityExpressionEqual (EqualityExpression_Binary -> EqualityExpression)
-> EqualityExpression_Binary -> EqualityExpression
forall a b. (a -> b) -> a -> b
$ EqualityExpression
-> RelationalExpression -> EqualityExpression_Binary
Java.EqualityExpression_Binary EqualityExpression
lhs RelationalExpression
rhs

javaEqualsNull :: Java.EqualityExpression -> Java.EqualityExpression
javaEqualsNull :: EqualityExpression -> EqualityExpression
javaEqualsNull EqualityExpression
lhs = EqualityExpression -> RelationalExpression -> EqualityExpression
javaEquals EqualityExpression
lhs (RelationalExpression -> EqualityExpression)
-> RelationalExpression -> EqualityExpression
forall a b. (a -> b) -> a -> b
$ Literal -> RelationalExpression
javaLiteralToJavaRelationalExpression Literal
Java.LiteralNull

javaExpressionNameToJavaExpression :: Java.ExpressionName -> Java.Expression
javaExpressionNameToJavaExpression :: ExpressionName -> Expression
javaExpressionNameToJavaExpression = PostfixExpression -> Expression
javaPostfixExpressionToJavaExpression (PostfixExpression -> Expression)
-> (ExpressionName -> PostfixExpression)
-> ExpressionName
-> Expression
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ExpressionName -> PostfixExpression
Java.PostfixExpressionName

javaExpressionToJavaPrimary :: Java.Expression -> Java.Primary
javaExpressionToJavaPrimary :: Expression -> Primary
javaExpressionToJavaPrimary = PrimaryNoNewArray -> Primary
Java.PrimaryNoNewArray (PrimaryNoNewArray -> Primary)
-> (Expression -> PrimaryNoNewArray) -> Expression -> Primary
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Expression -> PrimaryNoNewArray
Java.PrimaryNoNewArrayParens

javaExpressionToJavaUnaryExpression :: Java.Expression -> Java.UnaryExpression
javaExpressionToJavaUnaryExpression :: Expression -> UnaryExpression
javaExpressionToJavaUnaryExpression = Primary -> UnaryExpression
javaPrimaryToJavaUnaryExpression (Primary -> UnaryExpression)
-> (Expression -> Primary) -> Expression -> UnaryExpression
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Expression -> Primary
javaExpressionToJavaPrimary

javaFieldAccessToJavaExpression :: Java.FieldAccess -> Java.Expression
javaFieldAccessToJavaExpression :: FieldAccess -> Expression
javaFieldAccessToJavaExpression = Primary -> Expression
javaPrimaryToJavaExpression (Primary -> Expression)
-> (FieldAccess -> Primary) -> FieldAccess -> Expression
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PrimaryNoNewArray -> Primary
Java.PrimaryNoNewArray (PrimaryNoNewArray -> Primary)
-> (FieldAccess -> PrimaryNoNewArray) -> FieldAccess -> Primary
forall b c a. (b -> c) -> (a -> b) -> a -> c
. FieldAccess -> PrimaryNoNewArray
Java.PrimaryNoNewArrayFieldAccess

javaIdentifier :: String -> Java.Identifier
javaIdentifier :: String -> Identifier
javaIdentifier = String -> Identifier
Java.Identifier (String -> Identifier) -> ShowS -> String -> Identifier
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ShowS
sanitizeJavaName

javaIdentifierToJavaExpressionName :: Java.Identifier -> Java.ExpressionName
javaIdentifierToJavaExpressionName :: Identifier -> ExpressionName
javaIdentifierToJavaExpressionName Identifier
id = Maybe AmbiguousName -> Identifier -> ExpressionName
Java.ExpressionName Maybe AmbiguousName
forall a. Maybe a
Nothing Identifier
id

javaIdentifierToJavaExpression :: Java.Identifier -> Java.Expression
javaIdentifierToJavaExpression :: Identifier -> Expression
javaIdentifierToJavaExpression = UnaryExpression -> Expression
javaUnaryExpressionToJavaExpression (UnaryExpression -> Expression)
-> (Identifier -> UnaryExpression) -> Identifier -> Expression
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Identifier -> UnaryExpression
javaIdentifierToJavaUnaryExpression

javaIdentifierToJavaRelationalExpression :: Java.Identifier -> Java.RelationalExpression
javaIdentifierToJavaRelationalExpression :: Identifier -> RelationalExpression
javaIdentifierToJavaRelationalExpression Identifier
id = PostfixExpression -> RelationalExpression
javaPostfixExpressionToJavaRelationalExpression (PostfixExpression -> RelationalExpression)
-> PostfixExpression -> RelationalExpression
forall a b. (a -> b) -> a -> b
$
  ExpressionName -> PostfixExpression
Java.PostfixExpressionName (ExpressionName -> PostfixExpression)
-> ExpressionName -> PostfixExpression
forall a b. (a -> b) -> a -> b
$ Maybe AmbiguousName -> Identifier -> ExpressionName
Java.ExpressionName Maybe AmbiguousName
forall a. Maybe a
Nothing Identifier
id

javaIdentifierToJavaUnaryExpression :: Java.Identifier -> Java.UnaryExpression
javaIdentifierToJavaUnaryExpression :: Identifier -> UnaryExpression
javaIdentifierToJavaUnaryExpression = RelationalExpression -> UnaryExpression
javaRelationalExpressionToJavaUnaryExpression (RelationalExpression -> UnaryExpression)
-> (Identifier -> RelationalExpression)
-> Identifier
-> UnaryExpression
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Identifier -> RelationalExpression
javaIdentifierToJavaRelationalExpression

javaInstanceOf :: Java.RelationalExpression -> Java.ReferenceType -> Java.RelationalExpression
javaInstanceOf :: RelationalExpression -> ReferenceType -> RelationalExpression
javaInstanceOf RelationalExpression
lhs ReferenceType
rhs = RelationalExpression_InstanceOf -> RelationalExpression
Java.RelationalExpressionInstanceof (RelationalExpression_InstanceOf -> RelationalExpression)
-> RelationalExpression_InstanceOf -> RelationalExpression
forall a b. (a -> b) -> a -> b
$ RelationalExpression
-> ReferenceType -> RelationalExpression_InstanceOf
Java.RelationalExpression_InstanceOf RelationalExpression
lhs ReferenceType
rhs

javaInt :: Integral a => a -> Java.Literal
javaInt :: forall a. Integral a => a -> Literal
javaInt a
i = IntegerLiteral -> Literal
Java.LiteralInteger (IntegerLiteral -> Literal) -> IntegerLiteral -> Literal
forall a b. (a -> b) -> a -> b
$ Integer -> IntegerLiteral
Java.IntegerLiteral (Integer -> IntegerLiteral) -> Integer -> IntegerLiteral
forall a b. (a -> b) -> a -> b
$ a -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral a
i

javaIntExpression :: Integer -> Java.Expression
javaIntExpression :: Integer -> Expression
javaIntExpression = Primary -> Expression
javaPrimaryToJavaExpression (Primary -> Expression)
-> (Integer -> Primary) -> Integer -> Expression
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Literal -> Primary
javaLiteralToJavaPrimary (Literal -> Primary) -> (Integer -> Literal) -> Integer -> Primary
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Literal
forall a. Integral a => a -> Literal
javaInt

javaIntType :: Java.Type
javaIntType :: Type
javaIntType = PrimitiveType -> Type
javaPrimitiveTypeToJavaType (PrimitiveType -> Type) -> PrimitiveType -> Type
forall a b. (a -> b) -> a -> b
$ NumericType -> PrimitiveType
Java.PrimitiveTypeNumeric (NumericType -> PrimitiveType) -> NumericType -> PrimitiveType
forall a b. (a -> b) -> a -> b
$ IntegralType -> NumericType
Java.NumericTypeIntegral IntegralType
Java.IntegralTypeInt

javaInterfaceDeclarationToJavaClassBodyDeclaration :: Java.NormalInterfaceDeclaration -> Java.ClassBodyDeclaration
javaInterfaceDeclarationToJavaClassBodyDeclaration :: NormalInterfaceDeclaration -> ClassBodyDeclaration
javaInterfaceDeclarationToJavaClassBodyDeclaration = ClassMemberDeclaration -> ClassBodyDeclaration
Java.ClassBodyDeclarationClassMember (ClassMemberDeclaration -> ClassBodyDeclaration)
-> (NormalInterfaceDeclaration -> ClassMemberDeclaration)
-> NormalInterfaceDeclaration
-> ClassBodyDeclaration
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
  InterfaceDeclaration -> ClassMemberDeclaration
Java.ClassMemberDeclarationInterface (InterfaceDeclaration -> ClassMemberDeclaration)
-> (NormalInterfaceDeclaration -> InterfaceDeclaration)
-> NormalInterfaceDeclaration
-> ClassMemberDeclaration
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NormalInterfaceDeclaration -> InterfaceDeclaration
Java.InterfaceDeclarationNormalInterface

javaLambda :: Name -> Java.Expression -> Java.Expression
javaLambda :: Name -> Expression -> Expression
javaLambda Name
var Expression
jbody = LambdaExpression -> Expression
Java.ExpressionLambda (LambdaExpression -> Expression) -> LambdaExpression -> Expression
forall a b. (a -> b) -> a -> b
$ LambdaParameters -> LambdaBody -> LambdaExpression
Java.LambdaExpression LambdaParameters
params (Expression -> LambdaBody
Java.LambdaBodyExpression Expression
jbody)
  where
    params :: LambdaParameters
params = Identifier -> LambdaParameters
Java.LambdaParametersSingle (Identifier -> LambdaParameters) -> Identifier -> LambdaParameters
forall a b. (a -> b) -> a -> b
$ Name -> Identifier
variableToJavaIdentifier Name
var

javaLambdaFromBlock :: Name -> Java.Block -> Java.Expression
javaLambdaFromBlock :: Name -> Block -> Expression
javaLambdaFromBlock Name
var Block
block = LambdaExpression -> Expression
Java.ExpressionLambda (LambdaExpression -> Expression) -> LambdaExpression -> Expression
forall a b. (a -> b) -> a -> b
$ LambdaParameters -> LambdaBody -> LambdaExpression
Java.LambdaExpression LambdaParameters
params (Block -> LambdaBody
Java.LambdaBodyBlock Block
block)
  where
    params :: LambdaParameters
params = Identifier -> LambdaParameters
Java.LambdaParametersSingle (Identifier -> LambdaParameters) -> Identifier -> LambdaParameters
forall a b. (a -> b) -> a -> b
$ Name -> Identifier
variableToJavaIdentifier Name
var

javaLiteralToJavaRelationalExpression :: Java.Literal -> Java.RelationalExpression
javaLiteralToJavaRelationalExpression :: Literal -> RelationalExpression
javaLiteralToJavaRelationalExpression = MultiplicativeExpression -> RelationalExpression
javaMultiplicativeExpressionToJavaRelationalExpression (MultiplicativeExpression -> RelationalExpression)
-> (Literal -> MultiplicativeExpression)
-> Literal
-> RelationalExpression
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
  Literal -> MultiplicativeExpression
javaLiteralToJavaMultiplicativeExpression

javaLiteralToJavaExpression :: Literal -> Expression
javaLiteralToJavaExpression = RelationalExpression -> Expression
javaRelationalExpressionToJavaExpression (RelationalExpression -> Expression)
-> (Literal -> RelationalExpression) -> Literal -> Expression
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
  MultiplicativeExpression -> RelationalExpression
javaMultiplicativeExpressionToJavaRelationalExpression (MultiplicativeExpression -> RelationalExpression)
-> (Literal -> MultiplicativeExpression)
-> Literal
-> RelationalExpression
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
  Literal -> MultiplicativeExpression
javaLiteralToJavaMultiplicativeExpression

javaLiteralToJavaMultiplicativeExpression :: Literal -> MultiplicativeExpression
javaLiteralToJavaMultiplicativeExpression = UnaryExpression -> MultiplicativeExpression
Java.MultiplicativeExpressionUnary (UnaryExpression -> MultiplicativeExpression)
-> (Literal -> UnaryExpression)
-> Literal
-> MultiplicativeExpression
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Primary -> UnaryExpression
javaPrimaryToJavaUnaryExpression (Primary -> UnaryExpression)
-> (Literal -> Primary) -> Literal -> UnaryExpression
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
  Literal -> Primary
javaLiteralToJavaPrimary

javaLiteralToJavaPrimary :: Java.Literal -> Java.Primary
javaLiteralToJavaPrimary :: Literal -> Primary
javaLiteralToJavaPrimary = PrimaryNoNewArray -> Primary
Java.PrimaryNoNewArray (PrimaryNoNewArray -> Primary)
-> (Literal -> PrimaryNoNewArray) -> Literal -> Primary
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Literal -> PrimaryNoNewArray
Java.PrimaryNoNewArrayLiteral

javaMemberField :: [Java.FieldModifier] -> Java.Type -> Java.VariableDeclarator -> Java.ClassBodyDeclaration
javaMemberField :: [FieldModifier]
-> Type -> VariableDeclarator -> ClassBodyDeclaration
javaMemberField [FieldModifier]
mods Type
jt VariableDeclarator
var = ClassMemberDeclaration -> ClassBodyDeclaration
Java.ClassBodyDeclarationClassMember (ClassMemberDeclaration -> ClassBodyDeclaration)
-> ClassMemberDeclaration -> ClassBodyDeclaration
forall a b. (a -> b) -> a -> b
$ FieldDeclaration -> ClassMemberDeclaration
Java.ClassMemberDeclarationField (FieldDeclaration -> ClassMemberDeclaration)
-> FieldDeclaration -> ClassMemberDeclaration
forall a b. (a -> b) -> a -> b
$
  [FieldModifier]
-> UnannType -> [VariableDeclarator] -> FieldDeclaration
Java.FieldDeclaration [FieldModifier]
mods (Type -> UnannType
Java.UnannType Type
jt) [VariableDeclarator
var]

javaMethodBody :: Maybe [Java.BlockStatement] -> Java.MethodBody
javaMethodBody :: Maybe [BlockStatement] -> MethodBody
javaMethodBody Maybe [BlockStatement]
stmts = MethodBody
-> ([BlockStatement] -> MethodBody)
-> Maybe [BlockStatement]
-> MethodBody
forall b a. b -> (a -> b) -> Maybe a -> b
Y.maybe MethodBody
Java.MethodBodyNone (Block -> MethodBody
Java.MethodBodyBlock (Block -> MethodBody)
-> ([BlockStatement] -> Block) -> [BlockStatement] -> MethodBody
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [BlockStatement] -> Block
Java.Block) Maybe [BlockStatement]
stmts

javaMethodDeclarationToJavaClassBodyDeclaration :: Java.MethodDeclaration -> Java.ClassBodyDeclaration
javaMethodDeclarationToJavaClassBodyDeclaration :: MethodDeclaration -> ClassBodyDeclaration
javaMethodDeclarationToJavaClassBodyDeclaration = ClassMemberDeclaration -> ClassBodyDeclaration
Java.ClassBodyDeclarationClassMember (ClassMemberDeclaration -> ClassBodyDeclaration)
-> (MethodDeclaration -> ClassMemberDeclaration)
-> MethodDeclaration
-> ClassBodyDeclaration
forall b c a. (b -> c) -> (a -> b) -> a -> c
. MethodDeclaration -> ClassMemberDeclaration
Java.ClassMemberDeclarationMethod

javaMethodHeader :: [Java.TypeParameter] -> String -> [Java.FormalParameter] -> Java.Result -> Java.MethodHeader
javaMethodHeader :: [TypeParameter]
-> String -> [FormalParameter] -> Result -> MethodHeader
javaMethodHeader [TypeParameter]
tparams String
methodName [FormalParameter]
params Result
result = [TypeParameter]
-> Result -> MethodDeclarator -> Maybe Throws -> MethodHeader
Java.MethodHeader [TypeParameter]
tparams Result
result MethodDeclarator
decl Maybe Throws
forall a. Maybe a
mthrows
  where
    decl :: MethodDeclarator
decl = Identifier
-> Maybe ReceiverParameter -> [FormalParameter] -> MethodDeclarator
Java.MethodDeclarator (String -> Identifier
Java.Identifier String
methodName) Maybe ReceiverParameter
forall a. Maybe a
Nothing [FormalParameter]
params
    mthrows :: Maybe a
mthrows = Maybe a
forall a. Maybe a
Nothing

javaMethodInvocationToJavaExpression :: Java.MethodInvocation -> Java.Expression
javaMethodInvocationToJavaExpression :: MethodInvocation -> Expression
javaMethodInvocationToJavaExpression = Primary -> Expression
javaPrimaryToJavaExpression (Primary -> Expression)
-> (MethodInvocation -> Primary) -> MethodInvocation -> Expression
forall b c a. (b -> c) -> (a -> b) -> a -> c
. MethodInvocation -> Primary
javaMethodInvocationToJavaPrimary

javaMethodInvocationToJavaStatement :: Java.MethodInvocation -> Java.Statement
javaMethodInvocationToJavaStatement :: MethodInvocation -> Statement
javaMethodInvocationToJavaStatement = StatementWithoutTrailingSubstatement -> Statement
Java.StatementWithoutTrailing (StatementWithoutTrailingSubstatement -> Statement)
-> (MethodInvocation -> StatementWithoutTrailingSubstatement)
-> MethodInvocation
-> Statement
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ExpressionStatement -> StatementWithoutTrailingSubstatement
Java.StatementWithoutTrailingSubstatementExpression (ExpressionStatement -> StatementWithoutTrailingSubstatement)
-> (MethodInvocation -> ExpressionStatement)
-> MethodInvocation
-> StatementWithoutTrailingSubstatement
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
  StatementExpression -> ExpressionStatement
Java.ExpressionStatement (StatementExpression -> ExpressionStatement)
-> (MethodInvocation -> StatementExpression)
-> MethodInvocation
-> ExpressionStatement
forall b c a. (b -> c) -> (a -> b) -> a -> c
. MethodInvocation -> StatementExpression
Java.StatementExpressionMethodInvocation

javaMethodInvocationToJavaPostfixExpression :: Java.MethodInvocation -> Java.PostfixExpression
javaMethodInvocationToJavaPostfixExpression :: MethodInvocation -> PostfixExpression
javaMethodInvocationToJavaPostfixExpression = Primary -> PostfixExpression
Java.PostfixExpressionPrimary (Primary -> PostfixExpression)
-> (MethodInvocation -> Primary)
-> MethodInvocation
-> PostfixExpression
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PrimaryNoNewArray -> Primary
Java.PrimaryNoNewArray (PrimaryNoNewArray -> Primary)
-> (MethodInvocation -> PrimaryNoNewArray)
-> MethodInvocation
-> Primary
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
  MethodInvocation -> PrimaryNoNewArray
Java.PrimaryNoNewArrayMethodInvocation

javaMethodInvocationToJavaPrimary :: Java.MethodInvocation -> Java.Primary
javaMethodInvocationToJavaPrimary :: MethodInvocation -> Primary
javaMethodInvocationToJavaPrimary = PrimaryNoNewArray -> Primary
Java.PrimaryNoNewArray (PrimaryNoNewArray -> Primary)
-> (MethodInvocation -> PrimaryNoNewArray)
-> MethodInvocation
-> Primary
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
  MethodInvocation -> PrimaryNoNewArray
Java.PrimaryNoNewArrayMethodInvocation

javaMultiplicativeExpressionToJavaRelationalExpression :: Java.MultiplicativeExpression -> Java.RelationalExpression
javaMultiplicativeExpressionToJavaRelationalExpression :: MultiplicativeExpression -> RelationalExpression
javaMultiplicativeExpressionToJavaRelationalExpression = ShiftExpression -> RelationalExpression
Java.RelationalExpressionSimple (ShiftExpression -> RelationalExpression)
-> (MultiplicativeExpression -> ShiftExpression)
-> MultiplicativeExpression
-> RelationalExpression
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
  AdditiveExpression -> ShiftExpression
Java.ShiftExpressionUnary (AdditiveExpression -> ShiftExpression)
-> (MultiplicativeExpression -> AdditiveExpression)
-> MultiplicativeExpression
-> ShiftExpression
forall b c a. (b -> c) -> (a -> b) -> a -> c
. MultiplicativeExpression -> AdditiveExpression
Java.AdditiveExpressionUnary

javaPackageDeclaration :: Namespace -> Java.PackageDeclaration
javaPackageDeclaration :: Namespace -> PackageDeclaration
javaPackageDeclaration (Namespace String
name) = [PackageModifier] -> [Identifier] -> PackageDeclaration
Java.PackageDeclaration [] (String -> Identifier
Java.Identifier (String -> Identifier) -> [String] -> [Identifier]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> String -> String -> [String]
Strings.splitOn String
"/" String
name)

javaPostfixExpressionToJavaEqualityExpression :: Java.PostfixExpression -> Java.EqualityExpression
javaPostfixExpressionToJavaEqualityExpression :: PostfixExpression -> EqualityExpression
javaPostfixExpressionToJavaEqualityExpression = RelationalExpression -> EqualityExpression
Java.EqualityExpressionUnary (RelationalExpression -> EqualityExpression)
-> (PostfixExpression -> RelationalExpression)
-> PostfixExpression
-> EqualityExpression
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
  UnaryExpression -> RelationalExpression
javaUnaryExpressionToJavaRelationalExpression (UnaryExpression -> RelationalExpression)
-> (PostfixExpression -> UnaryExpression)
-> PostfixExpression
-> RelationalExpression
forall b c a. (b -> c) -> (a -> b) -> a -> c
. UnaryExpressionNotPlusMinus -> UnaryExpression
Java.UnaryExpressionOther (UnaryExpressionNotPlusMinus -> UnaryExpression)
-> (PostfixExpression -> UnaryExpressionNotPlusMinus)
-> PostfixExpression
-> UnaryExpression
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PostfixExpression -> UnaryExpressionNotPlusMinus
Java.UnaryExpressionNotPlusMinusPostfix

javaPostfixExpressionToJavaExpression :: Java.PostfixExpression -> Java.Expression
javaPostfixExpressionToJavaExpression :: PostfixExpression -> Expression
javaPostfixExpressionToJavaExpression = RelationalExpression -> Expression
javaRelationalExpressionToJavaExpression (RelationalExpression -> Expression)
-> (PostfixExpression -> RelationalExpression)
-> PostfixExpression
-> Expression
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
  PostfixExpression -> RelationalExpression
javaPostfixExpressionToJavaRelationalExpression

javaPostfixExpressionToJavaInclusiveOrExpression :: Java.PostfixExpression -> Java.InclusiveOrExpression
javaPostfixExpressionToJavaInclusiveOrExpression :: PostfixExpression -> InclusiveOrExpression
javaPostfixExpressionToJavaInclusiveOrExpression = EqualityExpression -> InclusiveOrExpression
javaEqualityExpressionToJavaInclusiveOrExpression (EqualityExpression -> InclusiveOrExpression)
-> (PostfixExpression -> EqualityExpression)
-> PostfixExpression
-> InclusiveOrExpression
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
  PostfixExpression -> EqualityExpression
javaPostfixExpressionToJavaEqualityExpression

javaPostfixExpressionToJavaRelationalExpression :: Java.PostfixExpression -> Java.RelationalExpression
javaPostfixExpressionToJavaRelationalExpression :: PostfixExpression -> RelationalExpression
javaPostfixExpressionToJavaRelationalExpression =
  UnaryExpression -> RelationalExpression
javaUnaryExpressionToJavaRelationalExpression (UnaryExpression -> RelationalExpression)
-> (PostfixExpression -> UnaryExpression)
-> PostfixExpression
-> RelationalExpression
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PostfixExpression -> UnaryExpression
javaPostfixExpressionToJavaUnaryExpression

javaPostfixExpressionToJavaUnaryExpression :: Java.PostfixExpression -> Java.UnaryExpression
javaPostfixExpressionToJavaUnaryExpression :: PostfixExpression -> UnaryExpression
javaPostfixExpressionToJavaUnaryExpression = UnaryExpressionNotPlusMinus -> UnaryExpression
Java.UnaryExpressionOther (UnaryExpressionNotPlusMinus -> UnaryExpression)
-> (PostfixExpression -> UnaryExpressionNotPlusMinus)
-> PostfixExpression
-> UnaryExpression
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PostfixExpression -> UnaryExpressionNotPlusMinus
Java.UnaryExpressionNotPlusMinusPostfix

javaPrimaryToJavaExpression :: Java.Primary -> Java.Expression
javaPrimaryToJavaExpression :: Primary -> Expression
javaPrimaryToJavaExpression = PostfixExpression -> Expression
javaPostfixExpressionToJavaExpression (PostfixExpression -> Expression)
-> (Primary -> PostfixExpression) -> Primary -> Expression
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Primary -> PostfixExpression
Java.PostfixExpressionPrimary

javaPrimaryToJavaUnaryExpression :: Java.Primary -> Java.UnaryExpression
javaPrimaryToJavaUnaryExpression :: Primary -> UnaryExpression
javaPrimaryToJavaUnaryExpression = UnaryExpressionNotPlusMinus -> UnaryExpression
Java.UnaryExpressionOther (UnaryExpressionNotPlusMinus -> UnaryExpression)
-> (Primary -> UnaryExpressionNotPlusMinus)
-> Primary
-> UnaryExpression
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
  PostfixExpression -> UnaryExpressionNotPlusMinus
Java.UnaryExpressionNotPlusMinusPostfix (PostfixExpression -> UnaryExpressionNotPlusMinus)
-> (Primary -> PostfixExpression)
-> Primary
-> UnaryExpressionNotPlusMinus
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
  Primary -> PostfixExpression
Java.PostfixExpressionPrimary

javaPrimitiveTypeToJavaType :: Java.PrimitiveType -> Java.Type
javaPrimitiveTypeToJavaType :: PrimitiveType -> Type
javaPrimitiveTypeToJavaType PrimitiveType
pt = PrimitiveTypeWithAnnotations -> Type
Java.TypePrimitive (PrimitiveTypeWithAnnotations -> Type)
-> PrimitiveTypeWithAnnotations -> Type
forall a b. (a -> b) -> a -> b
$ PrimitiveType -> [Annotation] -> PrimitiveTypeWithAnnotations
Java.PrimitiveTypeWithAnnotations PrimitiveType
pt []

javaRefType :: [Java.ReferenceType] -> Maybe Java.PackageName -> String -> Java.Type
javaRefType :: [ReferenceType] -> Maybe PackageName -> String -> Type
javaRefType [ReferenceType]
args Maybe PackageName
pkg String
id = ReferenceType -> Type
Java.TypeReference (ReferenceType -> Type) -> ReferenceType -> Type
forall a b. (a -> b) -> a -> b
$ ClassOrInterfaceType -> ReferenceType
Java.ReferenceTypeClassOrInterface (ClassOrInterfaceType -> ReferenceType)
-> ClassOrInterfaceType -> ReferenceType
forall a b. (a -> b) -> a -> b
$ ClassType -> ClassOrInterfaceType
Java.ClassOrInterfaceTypeClass (ClassType -> ClassOrInterfaceType)
-> ClassType -> ClassOrInterfaceType
forall a b. (a -> b) -> a -> b
$
  [ReferenceType] -> Maybe PackageName -> String -> ClassType
javaClassType [ReferenceType]
args Maybe PackageName
pkg String
id

javaRelationalExpressionToJavaEqualityExpression :: Java.RelationalExpression -> Java.EqualityExpression
javaRelationalExpressionToJavaEqualityExpression :: RelationalExpression -> EqualityExpression
javaRelationalExpressionToJavaEqualityExpression = RelationalExpression -> EqualityExpression
Java.EqualityExpressionUnary

javaRelationalExpressionToJavaExpression :: Java.RelationalExpression -> Java.Expression
javaRelationalExpressionToJavaExpression :: RelationalExpression -> Expression
javaRelationalExpressionToJavaExpression = EqualityExpression -> Expression
javaEqualityExpressionToJavaExpression (EqualityExpression -> Expression)
-> (RelationalExpression -> EqualityExpression)
-> RelationalExpression
-> Expression
forall b c a. (b -> c) -> (a -> b) -> a -> c
. RelationalExpression -> EqualityExpression
javaRelationalExpressionToJavaEqualityExpression

javaRelationalExpressionToJavaUnaryExpression :: Java.RelationalExpression -> Java.UnaryExpression
javaRelationalExpressionToJavaUnaryExpression :: RelationalExpression -> UnaryExpression
javaRelationalExpressionToJavaUnaryExpression = Primary -> UnaryExpression
javaPrimaryToJavaUnaryExpression (Primary -> UnaryExpression)
-> (RelationalExpression -> Primary)
-> RelationalExpression
-> UnaryExpression
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
  PrimaryNoNewArray -> Primary
Java.PrimaryNoNewArray (PrimaryNoNewArray -> Primary)
-> (RelationalExpression -> PrimaryNoNewArray)
-> RelationalExpression
-> Primary
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
  Expression -> PrimaryNoNewArray
Java.PrimaryNoNewArrayParens (Expression -> PrimaryNoNewArray)
-> (RelationalExpression -> Expression)
-> RelationalExpression
-> PrimaryNoNewArray
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
  RelationalExpression -> Expression
javaRelationalExpressionToJavaExpression

javaReturnStatement :: Y.Maybe Java.Expression -> Java.Statement
javaReturnStatement :: Maybe Expression -> Statement
javaReturnStatement = StatementWithoutTrailingSubstatement -> Statement
Java.StatementWithoutTrailing (StatementWithoutTrailingSubstatement -> Statement)
-> (Maybe Expression -> StatementWithoutTrailingSubstatement)
-> Maybe Expression
-> Statement
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ReturnStatement -> StatementWithoutTrailingSubstatement
Java.StatementWithoutTrailingSubstatementReturn (ReturnStatement -> StatementWithoutTrailingSubstatement)
-> (Maybe Expression -> ReturnStatement)
-> Maybe Expression
-> StatementWithoutTrailingSubstatement
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
  Maybe Expression -> ReturnStatement
Java.ReturnStatement

javaStatementsToBlock :: [Java.Statement] -> Java.Block
javaStatementsToBlock :: [Statement] -> Block
javaStatementsToBlock [Statement]
stmts = [BlockStatement] -> Block
Java.Block (Statement -> BlockStatement
Java.BlockStatementStatement (Statement -> BlockStatement) -> [Statement] -> [BlockStatement]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Statement]
stmts)

javaString :: String -> Java.Literal
javaString :: String -> Literal
javaString = StringLiteral -> Literal
Java.LiteralString (StringLiteral -> Literal)
-> (String -> StringLiteral) -> String -> Literal
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> StringLiteral
Java.StringLiteral

javaStringMultiplicativeExpression :: String -> Java.MultiplicativeExpression
javaStringMultiplicativeExpression :: String -> MultiplicativeExpression
javaStringMultiplicativeExpression = Literal -> MultiplicativeExpression
javaLiteralToJavaMultiplicativeExpression (Literal -> MultiplicativeExpression)
-> (String -> Literal) -> String -> MultiplicativeExpression
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Literal
javaString

javaThrowIllegalArgumentException :: [Java.Expression] -> Java.Statement
javaThrowIllegalArgumentException :: [Expression] -> Statement
javaThrowIllegalArgumentException [Expression]
args = Expression -> Statement
javaThrowStatement (Expression -> Statement) -> Expression -> Statement
forall a b. (a -> b) -> a -> b
$
  ClassOrInterfaceTypeToInstantiate
-> [Expression] -> Maybe ClassBody -> Expression
javaConstructorCall (Identifier
-> Maybe TypeArgumentsOrDiamond
-> ClassOrInterfaceTypeToInstantiate
javaConstructorName (String -> Identifier
Java.Identifier String
"IllegalArgumentException") Maybe TypeArgumentsOrDiamond
forall a. Maybe a
Nothing) [Expression]
args Maybe ClassBody
forall a. Maybe a
Nothing

javaThrowIllegalStateException :: [Java.Expression] -> Java.Statement
javaThrowIllegalStateException :: [Expression] -> Statement
javaThrowIllegalStateException [Expression]
args = Expression -> Statement
javaThrowStatement (Expression -> Statement) -> Expression -> Statement
forall a b. (a -> b) -> a -> b
$
  ClassOrInterfaceTypeToInstantiate
-> [Expression] -> Maybe ClassBody -> Expression
javaConstructorCall (Identifier
-> Maybe TypeArgumentsOrDiamond
-> ClassOrInterfaceTypeToInstantiate
javaConstructorName (String -> Identifier
Java.Identifier String
"IllegalStateException") Maybe TypeArgumentsOrDiamond
forall a. Maybe a
Nothing) [Expression]
args Maybe ClassBody
forall a. Maybe a
Nothing

javaThrowStatement :: Java.Expression -> Java.Statement
javaThrowStatement :: Expression -> Statement
javaThrowStatement = StatementWithoutTrailingSubstatement -> Statement
Java.StatementWithoutTrailing (StatementWithoutTrailingSubstatement -> Statement)
-> (Expression -> StatementWithoutTrailingSubstatement)
-> Expression
-> Statement
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
  ThrowStatement -> StatementWithoutTrailingSubstatement
Java.StatementWithoutTrailingSubstatementThrow (ThrowStatement -> StatementWithoutTrailingSubstatement)
-> (Expression -> ThrowStatement)
-> Expression
-> StatementWithoutTrailingSubstatement
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Expression -> ThrowStatement
Java.ThrowStatement

javaThis :: Java.Expression
javaThis :: Expression
javaThis = Primary -> Expression
javaPrimaryToJavaExpression (Primary -> Expression) -> Primary -> Expression
forall a b. (a -> b) -> a -> b
$ PrimaryNoNewArray -> Primary
Java.PrimaryNoNewArray PrimaryNoNewArray
Java.PrimaryNoNewArrayThis

javaTypeFromTypeName :: Aliases -> Name -> Java.Type
javaTypeFromTypeName :: Aliases -> Name -> Type
javaTypeFromTypeName Aliases
aliases Name
elName = TypeVariable -> Type
javaTypeVariableToType (TypeVariable -> Type) -> TypeVariable -> Type
forall a b. (a -> b) -> a -> b
$ [Annotation] -> TypeIdentifier -> TypeVariable
Java.TypeVariable [] (TypeIdentifier -> TypeVariable) -> TypeIdentifier -> TypeVariable
forall a b. (a -> b) -> a -> b
$
  Aliases -> Bool -> Name -> TypeIdentifier
nameToJavaTypeIdentifier Aliases
aliases Bool
False Name
elName

javaTypeIdentifier :: String -> Java.TypeIdentifier
javaTypeIdentifier :: String -> TypeIdentifier
javaTypeIdentifier = Identifier -> TypeIdentifier
Java.TypeIdentifier (Identifier -> TypeIdentifier)
-> (String -> Identifier) -> String -> TypeIdentifier
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Identifier
Java.Identifier

javaTypeIdentifierToJavaTypeArgument :: Java.TypeIdentifier -> Java.TypeArgument
javaTypeIdentifierToJavaTypeArgument :: TypeIdentifier -> TypeArgument
javaTypeIdentifierToJavaTypeArgument TypeIdentifier
id = ReferenceType -> TypeArgument
Java.TypeArgumentReference (ReferenceType -> TypeArgument) -> ReferenceType -> TypeArgument
forall a b. (a -> b) -> a -> b
$ TypeVariable -> ReferenceType
Java.ReferenceTypeVariable (TypeVariable -> ReferenceType) -> TypeVariable -> ReferenceType
forall a b. (a -> b) -> a -> b
$ [Annotation] -> TypeIdentifier -> TypeVariable
Java.TypeVariable [] TypeIdentifier
id

javaTypeName :: Java.Identifier -> Java.TypeName
javaTypeName :: Identifier -> TypeName
javaTypeName Identifier
id = TypeIdentifier -> Maybe PackageOrTypeName -> TypeName
Java.TypeName (Identifier -> TypeIdentifier
Java.TypeIdentifier Identifier
id) Maybe PackageOrTypeName
forall a. Maybe a
Nothing

javaTypeParameter :: String -> Java.TypeParameter
javaTypeParameter :: String -> TypeParameter
javaTypeParameter String
v = [TypeParameterModifier]
-> TypeIdentifier -> Maybe TypeBound -> TypeParameter
Java.TypeParameter [] (String -> TypeIdentifier
javaTypeIdentifier String
v) Maybe TypeBound
forall a. Maybe a
Nothing

javaTypeToJavaFormalParameter :: Java.Type -> Name -> Java.FormalParameter
javaTypeToJavaFormalParameter :: Type -> Name -> FormalParameter
javaTypeToJavaFormalParameter Type
jt Name
fname = FormalParameter_Simple -> FormalParameter
Java.FormalParameterSimple (FormalParameter_Simple -> FormalParameter)
-> FormalParameter_Simple -> FormalParameter
forall a b. (a -> b) -> a -> b
$ [VariableModifier]
-> UnannType -> VariableDeclaratorId -> FormalParameter_Simple
Java.FormalParameter_Simple [] UnannType
argType VariableDeclaratorId
argId
  where
    argType :: UnannType
argType = Type -> UnannType
Java.UnannType Type
jt
    argId :: VariableDeclaratorId
argId = Name -> VariableDeclaratorId
fieldNameToJavaVariableDeclaratorId Name
fname

javaTypeToJavaReferenceType :: Java.Type -> Flow (Graph) Java.ReferenceType
javaTypeToJavaReferenceType :: Type -> Flow Graph ReferenceType
javaTypeToJavaReferenceType Type
t = case Type
t of
  Java.TypeReference ReferenceType
rt -> ReferenceType -> Flow Graph ReferenceType
forall a. a -> Flow Graph a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ReferenceType
rt
  Type
_ -> String -> Flow Graph ReferenceType
forall a. String -> Flow Graph a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> Flow Graph ReferenceType)
-> String -> Flow Graph ReferenceType
forall a b. (a -> b) -> a -> b
$ String
"expected a Java reference type. Found: " String -> ShowS
forall a. [a] -> [a] -> [a]
++ Type -> String
forall a. Show a => a -> String
show Type
t

javaTypeToJavaResult :: Java.Type -> Java.Result
javaTypeToJavaResult :: Type -> Result
javaTypeToJavaResult = UnannType -> Result
Java.ResultType (UnannType -> Result) -> (Type -> UnannType) -> Type -> Result
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Type -> UnannType
Java.UnannType

javaTypeToJavaTypeArgument :: Java.Type -> Java.TypeArgument
javaTypeToJavaTypeArgument :: Type -> TypeArgument
javaTypeToJavaTypeArgument Type
t = case Type
t of
  Java.TypeReference ReferenceType
rt -> ReferenceType -> TypeArgument
Java.TypeArgumentReference ReferenceType
rt
  Type
_ -> Wildcard -> TypeArgument
Java.TypeArgumentWildcard (Wildcard -> TypeArgument) -> Wildcard -> TypeArgument
forall a b. (a -> b) -> a -> b
$ [Annotation] -> Maybe WildcardBounds -> Wildcard
Java.Wildcard [] Maybe WildcardBounds
forall a. Maybe a
Nothing -- TODO

javaTypeVariable :: String -> Java.ReferenceType
javaTypeVariable :: String -> ReferenceType
javaTypeVariable String
v = TypeVariable -> ReferenceType
Java.ReferenceTypeVariable (TypeVariable -> ReferenceType) -> TypeVariable -> ReferenceType
forall a b. (a -> b) -> a -> b
$ [Annotation] -> TypeIdentifier -> TypeVariable
Java.TypeVariable [] (TypeIdentifier -> TypeVariable) -> TypeIdentifier -> TypeVariable
forall a b. (a -> b) -> a -> b
$ String -> TypeIdentifier
javaTypeIdentifier (String -> TypeIdentifier) -> String -> TypeIdentifier
forall a b. (a -> b) -> a -> b
$ ShowS
capitalize String
v

javaTypeVariableToType :: Java.TypeVariable -> Java.Type
javaTypeVariableToType :: TypeVariable -> Type
javaTypeVariableToType = ReferenceType -> Type
Java.TypeReference (ReferenceType -> Type)
-> (TypeVariable -> ReferenceType) -> TypeVariable -> Type
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TypeVariable -> ReferenceType
Java.ReferenceTypeVariable

javaUnaryExpressionToJavaExpression :: Java.UnaryExpression -> Java.Expression
javaUnaryExpressionToJavaExpression :: UnaryExpression -> Expression
javaUnaryExpressionToJavaExpression = RelationalExpression -> Expression
javaRelationalExpressionToJavaExpression (RelationalExpression -> Expression)
-> (UnaryExpression -> RelationalExpression)
-> UnaryExpression
-> Expression
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
  UnaryExpression -> RelationalExpression
javaUnaryExpressionToJavaRelationalExpression

javaUnaryExpressionToJavaRelationalExpression :: Java.UnaryExpression -> Java.RelationalExpression
javaUnaryExpressionToJavaRelationalExpression :: UnaryExpression -> RelationalExpression
javaUnaryExpressionToJavaRelationalExpression = MultiplicativeExpression -> RelationalExpression
javaMultiplicativeExpressionToJavaRelationalExpression (MultiplicativeExpression -> RelationalExpression)
-> (UnaryExpression -> MultiplicativeExpression)
-> UnaryExpression
-> RelationalExpression
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
  UnaryExpression -> MultiplicativeExpression
Java.MultiplicativeExpressionUnary

javaVariableDeclarator :: Java.Identifier -> Y.Maybe Java.VariableInitializer -> Java.VariableDeclarator
javaVariableDeclarator :: Identifier -> Maybe VariableInitializer -> VariableDeclarator
javaVariableDeclarator Identifier
id = VariableDeclaratorId
-> Maybe VariableInitializer -> VariableDeclarator
Java.VariableDeclarator (Identifier -> VariableDeclaratorId
javaVariableDeclaratorId Identifier
id)

javaVariableDeclaratorId :: Java.Identifier -> Java.VariableDeclaratorId
javaVariableDeclaratorId :: Identifier -> VariableDeclaratorId
javaVariableDeclaratorId Identifier
id = Identifier -> Maybe Dims -> VariableDeclaratorId
Java.VariableDeclaratorId Identifier
id Maybe Dims
forall a. Maybe a
Nothing

javaVariableName :: Name -> Java.Identifier
javaVariableName :: Name -> Identifier
javaVariableName = String -> Identifier
javaIdentifier (String -> Identifier) -> (Name -> String) -> Name -> Identifier
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Name -> String
localNameOfEager

makeConstructor :: Aliases -> Name -> Bool -> [Java.FormalParameter]
  -> [Java.BlockStatement] -> Java.ClassBodyDeclaration
makeConstructor :: Aliases
-> Name
-> Bool
-> [FormalParameter]
-> [BlockStatement]
-> ClassBodyDeclaration
makeConstructor Aliases
aliases Name
elName Bool
private [FormalParameter]
params [BlockStatement]
stmts = ConstructorDeclaration -> ClassBodyDeclaration
Java.ClassBodyDeclarationConstructorDeclaration (ConstructorDeclaration -> ClassBodyDeclaration)
-> ConstructorDeclaration -> ClassBodyDeclaration
forall a b. (a -> b) -> a -> b
$
    [ConstructorModifier]
-> ConstructorDeclarator
-> Maybe Throws
-> ConstructorBody
-> ConstructorDeclaration
Java.ConstructorDeclaration [ConstructorModifier]
mods ConstructorDeclarator
cons Maybe Throws
forall a. Maybe a
Nothing ConstructorBody
body
  where
    nm :: SimpleTypeName
nm = TypeIdentifier -> SimpleTypeName
Java.SimpleTypeName (TypeIdentifier -> SimpleTypeName)
-> TypeIdentifier -> SimpleTypeName
forall a b. (a -> b) -> a -> b
$ Aliases -> Bool -> Name -> TypeIdentifier
nameToJavaTypeIdentifier Aliases
aliases Bool
False Name
elName
    cons :: ConstructorDeclarator
cons = [TypeParameter]
-> SimpleTypeName
-> Maybe ReceiverParameter
-> [FormalParameter]
-> ConstructorDeclarator
Java.ConstructorDeclarator [] SimpleTypeName
nm Maybe ReceiverParameter
forall a. Maybe a
Nothing [FormalParameter]
params
    mods :: [ConstructorModifier]
mods = [if Bool
private then ConstructorModifier
Java.ConstructorModifierPrivate else ConstructorModifier
Java.ConstructorModifierPublic]
    body :: ConstructorBody
body = Maybe ExplicitConstructorInvocation
-> [BlockStatement] -> ConstructorBody
Java.ConstructorBody Maybe ExplicitConstructorInvocation
forall a. Maybe a
Nothing [BlockStatement]
stmts

methodDeclaration :: [Java.MethodModifier] -> [Java.TypeParameter] -> [Java.Annotation] -> String
  -> [Java.FormalParameter] -> Java.Result -> Maybe [Java.BlockStatement] -> Java.ClassBodyDeclaration
methodDeclaration :: [MethodModifier]
-> [TypeParameter]
-> [Annotation]
-> String
-> [FormalParameter]
-> Result
-> Maybe [BlockStatement]
-> ClassBodyDeclaration
methodDeclaration [MethodModifier]
mods [TypeParameter]
tparams [Annotation]
anns String
methodName [FormalParameter]
params Result
result Maybe [BlockStatement]
stmts =
    MethodDeclaration -> ClassBodyDeclaration
javaMethodDeclarationToJavaClassBodyDeclaration (MethodDeclaration -> ClassBodyDeclaration)
-> MethodDeclaration -> ClassBodyDeclaration
forall a b. (a -> b) -> a -> b
$
    [Annotation]
-> [MethodModifier]
-> MethodHeader
-> MethodBody
-> MethodDeclaration
Java.MethodDeclaration [Annotation]
anns [MethodModifier]
mods MethodHeader
header MethodBody
body
  where
    header :: MethodHeader
header = [TypeParameter]
-> String -> [FormalParameter] -> Result -> MethodHeader
javaMethodHeader [TypeParameter]
tparams String
methodName [FormalParameter]
params Result
result
    body :: MethodBody
body = Maybe [BlockStatement] -> MethodBody
javaMethodBody Maybe [BlockStatement]
stmts

methodInvocation :: Y.Maybe (Either Java.ExpressionName Java.Primary) -> Java.Identifier -> [Java.Expression] -> Java.MethodInvocation
methodInvocation :: Maybe (Either ExpressionName Primary)
-> Identifier -> [Expression] -> MethodInvocation
methodInvocation Maybe (Either ExpressionName Primary)
lhs Identifier
methodName = MethodInvocation_Header -> [Expression] -> MethodInvocation
Java.MethodInvocation MethodInvocation_Header
header
  where
    header :: MethodInvocation_Header
header = case Maybe (Either ExpressionName Primary)
lhs of
      Maybe (Either ExpressionName Primary)
Nothing -> MethodName -> MethodInvocation_Header
Java.MethodInvocation_HeaderSimple (MethodName -> MethodInvocation_Header)
-> MethodName -> MethodInvocation_Header
forall a b. (a -> b) -> a -> b
$ Identifier -> MethodName
Java.MethodName Identifier
methodName
      Just Either ExpressionName Primary
either -> MethodInvocation_Complex -> MethodInvocation_Header
Java.MethodInvocation_HeaderComplex (MethodInvocation_Complex -> MethodInvocation_Header)
-> MethodInvocation_Complex -> MethodInvocation_Header
forall a b. (a -> b) -> a -> b
$ MethodInvocation_Variant
-> [TypeArgument] -> Identifier -> MethodInvocation_Complex
Java.MethodInvocation_Complex MethodInvocation_Variant
variant [TypeArgument]
forall a. [a]
targs Identifier
methodName
        where
          targs :: [a]
targs = []
          variant :: MethodInvocation_Variant
variant = case Either ExpressionName Primary
either of
            Left ExpressionName
name -> ExpressionName -> MethodInvocation_Variant
Java.MethodInvocation_VariantExpression ExpressionName
name
            Right Primary
prim -> Primary -> MethodInvocation_Variant
Java.MethodInvocation_VariantPrimary Primary
prim

methodInvocationStatic :: Java.Identifier -> Java.Identifier -> [Java.Expression] -> Java.MethodInvocation
methodInvocationStatic :: Identifier -> Identifier -> [Expression] -> MethodInvocation
methodInvocationStatic Identifier
self Identifier
methodName = Maybe (Either ExpressionName Primary)
-> Identifier -> [Expression] -> MethodInvocation
methodInvocation (Either ExpressionName Primary
-> Maybe (Either ExpressionName Primary)
forall a. a -> Maybe a
Just (Either ExpressionName Primary
 -> Maybe (Either ExpressionName Primary))
-> Either ExpressionName Primary
-> Maybe (Either ExpressionName Primary)
forall a b. (a -> b) -> a -> b
$ ExpressionName -> Either ExpressionName Primary
forall a b. a -> Either a b
Left ExpressionName
name) Identifier
methodName
  where
    name :: ExpressionName
name = Maybe AmbiguousName -> Identifier -> ExpressionName
Java.ExpressionName Maybe AmbiguousName
forall a. Maybe a
Nothing Identifier
self

nameToJavaClassType :: Aliases -> Bool -> [Java.TypeArgument] -> Name -> Maybe String -> Java.ClassType
nameToJavaClassType :: Aliases
-> Bool -> [TypeArgument] -> Name -> Maybe String -> ClassType
nameToJavaClassType Aliases
aliases Bool
qualify [TypeArgument]
args Name
name Maybe String
mlocal = [Annotation]
-> ClassTypeQualifier
-> TypeIdentifier
-> [TypeArgument]
-> ClassType
Java.ClassType [] ClassTypeQualifier
pkg TypeIdentifier
id [TypeArgument]
args
  where
    (TypeIdentifier
id, ClassTypeQualifier
pkg) = Aliases
-> Bool
-> Name
-> Maybe String
-> (TypeIdentifier, ClassTypeQualifier)
nameToQualifiedJavaName Aliases
aliases Bool
qualify Name
name Maybe String
mlocal

nameToQualifiedJavaName :: Aliases -> Bool -> Name -> Maybe String -> (Java.TypeIdentifier, Java.ClassTypeQualifier)
nameToQualifiedJavaName :: Aliases
-> Bool
-> Name
-> Maybe String
-> (TypeIdentifier, ClassTypeQualifier)
nameToQualifiedJavaName Aliases
aliases Bool
qualify Name
name Maybe String
mlocal = (TypeIdentifier
jid, ClassTypeQualifier
pkg)
  where
    QualifiedName Maybe Namespace
ns String
local = Name -> QualifiedName
qualifyNameEager Name
name
    alias :: Maybe PackageName
alias = case Maybe Namespace
ns of
      Maybe Namespace
Nothing -> Maybe PackageName
forall a. Maybe a
Nothing
      Just Namespace
n -> case Namespace -> PackageMap -> Maybe PackageName
forall k a. Ord k => k -> Map k a -> Maybe a
M.lookup Namespace
n (Aliases -> PackageMap
aliasesPackages Aliases
aliases) of
          Maybe PackageName
Nothing -> PackageName -> Maybe PackageName
forall a. a -> Maybe a
Just (PackageName -> Maybe PackageName)
-> PackageName -> Maybe PackageName
forall a b. (a -> b) -> a -> b
$ [String] -> PackageName
javaPackageName ([String] -> PackageName) -> [String] -> PackageName
forall a b. (a -> b) -> a -> b
$ String -> String -> [String]
Strings.splitOn String
"/" (String -> [String]) -> String -> [String]
forall a b. (a -> b) -> a -> b
$ Namespace -> String
unNamespace Namespace
n
          Just PackageName
id -> PackageName -> Maybe PackageName
forall a. a -> Maybe a
Just PackageName
id
    pkg :: ClassTypeQualifier
pkg = if Bool
qualify
      then ClassTypeQualifier
-> (PackageName -> ClassTypeQualifier)
-> Maybe PackageName
-> ClassTypeQualifier
forall b a. b -> (a -> b) -> Maybe a -> b
Y.maybe ClassTypeQualifier
none PackageName -> ClassTypeQualifier
Java.ClassTypeQualifierPackage Maybe PackageName
alias
      else ClassTypeQualifier
none
    none :: ClassTypeQualifier
none = ClassTypeQualifier
Java.ClassTypeQualifierNone
    jid :: TypeIdentifier
jid = String -> TypeIdentifier
javaTypeIdentifier (String -> TypeIdentifier) -> String -> TypeIdentifier
forall a b. (a -> b) -> a -> b
$ case Maybe String
mlocal of
      Maybe String
Nothing -> ShowS
sanitizeJavaName String
local
      Just String
l -> ShowS
sanitizeJavaName String
local String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
"." String -> ShowS
forall a. [a] -> [a] -> [a]
++ ShowS
sanitizeJavaName String
l

nameToJavaName :: Aliases -> Name -> Java.Identifier
nameToJavaName :: Aliases -> Name -> Identifier
nameToJavaName Aliases
aliases Name
name = String -> Identifier
Java.Identifier (String -> Identifier) -> String -> Identifier
forall a b. (a -> b) -> a -> b
$ if String -> Bool
isEscaped (Name -> String
unName Name
name)
    then ShowS
sanitizeJavaName String
local
    else case Maybe Namespace
ns of
      Maybe Namespace
Nothing -> String
local
      Just Namespace
gname -> case Namespace -> PackageMap -> Maybe PackageName
forall k a. Ord k => k -> Map k a -> Maybe a
M.lookup Namespace
gname (Aliases -> PackageMap
aliasesPackages Aliases
aliases) of
        Maybe PackageName
Nothing -> [String] -> String
fromParts ([String] -> String) -> [String] -> String
forall a b. (a -> b) -> a -> b
$ String -> String -> [String]
Strings.splitOn String
"/" (String -> [String]) -> String -> [String]
forall a b. (a -> b) -> a -> b
$ Namespace -> String
unNamespace Namespace
gname
        Just (Java.PackageName [Identifier]
parts) -> [String] -> String
fromParts (Identifier -> String
Java.unIdentifier (Identifier -> String) -> [Identifier] -> [String]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Identifier]
parts)
  where
    QualifiedName Maybe Namespace
ns String
local = Name -> QualifiedName
qualifyNameEager Name
name
    fromParts :: [String] -> String
fromParts [String]
parts = String -> [String] -> String
forall a. [a] -> [[a]] -> [a]
L.intercalate String
"." ([String] -> String) -> [String] -> String
forall a b. (a -> b) -> a -> b
$ [String]
parts [String] -> [String] -> [String]
forall a. [a] -> [a] -> [a]
++ [ShowS
sanitizeJavaName String
local]

nameToJavaReferenceType :: Aliases -> Bool -> [Java.TypeArgument] -> Name -> Maybe String -> Java.ReferenceType
nameToJavaReferenceType :: Aliases
-> Bool -> [TypeArgument] -> Name -> Maybe String -> ReferenceType
nameToJavaReferenceType Aliases
aliases Bool
qualify [TypeArgument]
args Name
name Maybe String
mlocal = ClassOrInterfaceType -> ReferenceType
Java.ReferenceTypeClassOrInterface (ClassOrInterfaceType -> ReferenceType)
-> ClassOrInterfaceType -> ReferenceType
forall a b. (a -> b) -> a -> b
$ ClassType -> ClassOrInterfaceType
Java.ClassOrInterfaceTypeClass (ClassType -> ClassOrInterfaceType)
-> ClassType -> ClassOrInterfaceType
forall a b. (a -> b) -> a -> b
$
  Aliases
-> Bool -> [TypeArgument] -> Name -> Maybe String -> ClassType
nameToJavaClassType Aliases
aliases Bool
qualify [TypeArgument]
args Name
name Maybe String
mlocal

nameToJavaTypeIdentifier :: Aliases -> Bool -> Name -> Java.TypeIdentifier
nameToJavaTypeIdentifier :: Aliases -> Bool -> Name -> TypeIdentifier
nameToJavaTypeIdentifier Aliases
aliases Bool
qualify Name
name = (TypeIdentifier, ClassTypeQualifier) -> TypeIdentifier
forall a b. (a, b) -> a
fst ((TypeIdentifier, ClassTypeQualifier) -> TypeIdentifier)
-> (TypeIdentifier, ClassTypeQualifier) -> TypeIdentifier
forall a b. (a -> b) -> a -> b
$ Aliases
-> Bool
-> Name
-> Maybe String
-> (TypeIdentifier, ClassTypeQualifier)
nameToQualifiedJavaName Aliases
aliases Bool
qualify Name
name Maybe String
forall a. Maybe a
Nothing

overrideAnnotation :: Java.Annotation
overrideAnnotation :: Annotation
overrideAnnotation = MarkerAnnotation -> Annotation
Java.AnnotationMarker (MarkerAnnotation -> Annotation) -> MarkerAnnotation -> Annotation
forall a b. (a -> b) -> a -> b
$ TypeName -> MarkerAnnotation
Java.MarkerAnnotation (TypeName -> MarkerAnnotation) -> TypeName -> MarkerAnnotation
forall a b. (a -> b) -> a -> b
$ Identifier -> TypeName
javaTypeName (Identifier -> TypeName) -> Identifier -> TypeName
forall a b. (a -> b) -> a -> b
$ String -> Identifier
Java.Identifier String
"Override"

referenceTypeToResult :: Java.ReferenceType -> Java.Result
referenceTypeToResult :: ReferenceType -> Result
referenceTypeToResult = Type -> Result
javaTypeToJavaResult (Type -> Result)
-> (ReferenceType -> Type) -> ReferenceType -> Result
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ReferenceType -> Type
Java.TypeReference

sanitizeJavaName :: String -> String
sanitizeJavaName :: ShowS
sanitizeJavaName String
name = if String -> Bool
isEscaped String
name
  -- The '$' prefix allows names to be excluded from sanitization
  then ShowS
unescape String
name
  else Set String -> ShowS
sanitizeWithUnderscores Set String
reservedWords String
name

toAcceptMethod :: Bool -> [Java.TypeParameter] -> Java.ClassBodyDeclaration
toAcceptMethod :: Bool -> [TypeParameter] -> ClassBodyDeclaration
toAcceptMethod Bool
abstract [TypeParameter]
vtparams = [MethodModifier]
-> [TypeParameter]
-> [Annotation]
-> String
-> [FormalParameter]
-> Result
-> Maybe [BlockStatement]
-> ClassBodyDeclaration
methodDeclaration [MethodModifier]
mods [TypeParameter]
tparams [Annotation]
anns String
acceptMethodName [FormalParameter
param] Result
result Maybe [BlockStatement]
body
  where
    mods :: [MethodModifier]
mods = [MethodModifier
Java.MethodModifierPublic] [MethodModifier] -> [MethodModifier] -> [MethodModifier]
forall a. [a] -> [a] -> [a]
++ if Bool
abstract then [MethodModifier
Java.MethodModifierAbstract] else []
    tparams :: [TypeParameter]
tparams = [String -> TypeParameter
javaTypeParameter String
visitorReturnParameter]
    anns :: [Annotation]
anns = if Bool
abstract
      then []
      else [Annotation
overrideAnnotation]
    param :: FormalParameter
param = Type -> Name -> FormalParameter
javaTypeToJavaFormalParameter Type
ref (String -> Name
Name String
varName)
      where
        ref :: Type
ref = ClassType -> Type
javaClassTypeToJavaType (ClassType -> Type) -> ClassType -> Type
forall a b. (a -> b) -> a -> b
$
          [Annotation]
-> ClassTypeQualifier
-> TypeIdentifier
-> [TypeArgument]
-> ClassType
Java.ClassType
            []
            ClassTypeQualifier
Java.ClassTypeQualifierNone
            (String -> TypeIdentifier
javaTypeIdentifier String
visitorName)
            ([TypeArgument]
typeArgs [TypeArgument] -> [TypeArgument] -> [TypeArgument]
forall a. [a] -> [a] -> [a]
++ [ReferenceType -> TypeArgument
Java.TypeArgumentReference ReferenceType
visitorTypeVariable])
    typeArgs :: [TypeArgument]
typeArgs = (ReferenceType -> TypeArgument
Java.TypeArgumentReference (ReferenceType -> TypeArgument)
-> (TypeParameter -> ReferenceType)
-> TypeParameter
-> TypeArgument
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TypeParameter -> ReferenceType
typeParameterToReferenceType) (TypeParameter -> TypeArgument)
-> [TypeParameter] -> [TypeArgument]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [TypeParameter]
vtparams
    result :: Result
result = Type -> Result
javaTypeToJavaResult (Type -> Result) -> Type -> Result
forall a b. (a -> b) -> a -> b
$ ReferenceType -> Type
Java.TypeReference ReferenceType
visitorTypeVariable
    varName :: String
varName = String
"visitor"
    body :: Maybe [BlockStatement]
body = if Bool
abstract
      then Maybe [BlockStatement]
forall a. Maybe a
Nothing
      else [BlockStatement] -> Maybe [BlockStatement]
forall a. a -> Maybe a
Just [Statement -> BlockStatement
Java.BlockStatementStatement (Statement -> BlockStatement) -> Statement -> BlockStatement
forall a b. (a -> b) -> a -> b
$ Maybe Expression -> Statement
javaReturnStatement (Maybe Expression -> Statement) -> Maybe Expression -> Statement
forall a b. (a -> b) -> a -> b
$ Expression -> Maybe Expression
forall a. a -> Maybe a
Just Expression
returnExpr]
    returnExpr :: Expression
returnExpr = MethodInvocation -> Expression
javaMethodInvocationToJavaExpression (MethodInvocation -> Expression) -> MethodInvocation -> Expression
forall a b. (a -> b) -> a -> b
$
        Identifier -> Identifier -> [Expression] -> MethodInvocation
methodInvocationStatic (String -> Identifier
Java.Identifier String
varName) (String -> Identifier
Java.Identifier String
visitMethodName) [Expression
javaThis]

toAssignStmt :: Name -> Java.Statement
toAssignStmt :: Name -> Statement
toAssignStmt Name
fname = LeftHandSide -> Expression -> Statement
javaAssignmentStatement LeftHandSide
lhs Expression
rhs
  where
    lhs :: LeftHandSide
lhs = FieldAccess -> LeftHandSide
Java.LeftHandSideFieldAccess (FieldAccess -> LeftHandSide) -> FieldAccess -> LeftHandSide
forall a b. (a -> b) -> a -> b
$ Identifier -> FieldAccess
thisField Identifier
id
      where
        id :: Identifier
id = Name -> Identifier
fieldNameToJavaIdentifier Name
fname
    rhs :: Expression
rhs = Name -> Expression
fieldNameToJavaExpression Name
fname
    thisField :: Identifier -> FieldAccess
thisField = FieldAccess_Qualifier -> Identifier -> FieldAccess
Java.FieldAccess (FieldAccess_Qualifier -> Identifier -> FieldAccess)
-> FieldAccess_Qualifier -> Identifier -> FieldAccess
forall a b. (a -> b) -> a -> b
$ Primary -> FieldAccess_Qualifier
Java.FieldAccess_QualifierPrimary (Primary -> FieldAccess_Qualifier)
-> Primary -> FieldAccess_Qualifier
forall a b. (a -> b) -> a -> b
$ PrimaryNoNewArray -> Primary
Java.PrimaryNoNewArray PrimaryNoNewArray
Java.PrimaryNoNewArrayThis

toJavaArrayType :: Java.Type -> Flow (Graph) Java.Type
toJavaArrayType :: Type -> Flow Graph Type
toJavaArrayType Type
t = ReferenceType -> Type
Java.TypeReference (ReferenceType -> Type)
-> (ArrayType -> ReferenceType) -> ArrayType -> Type
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ArrayType -> ReferenceType
Java.ReferenceTypeArray (ArrayType -> Type) -> Flow Graph ArrayType -> Flow Graph Type
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> case Type
t of
  Java.TypeReference ReferenceType
rt -> case ReferenceType
rt of
    Java.ReferenceTypeClassOrInterface ClassOrInterfaceType
cit -> ArrayType -> Flow Graph ArrayType
forall a. a -> Flow Graph a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ArrayType -> Flow Graph ArrayType)
-> ArrayType -> Flow Graph ArrayType
forall a b. (a -> b) -> a -> b
$
      Dims -> ArrayType_Variant -> ArrayType
Java.ArrayType ([[Annotation]] -> Dims
Java.Dims [[]]) (ArrayType_Variant -> ArrayType) -> ArrayType_Variant -> ArrayType
forall a b. (a -> b) -> a -> b
$ ClassOrInterfaceType -> ArrayType_Variant
Java.ArrayType_VariantClassOrInterface ClassOrInterfaceType
cit
    Java.ReferenceTypeArray (Java.ArrayType (Java.Dims [[Annotation]]
d) ArrayType_Variant
v) -> ArrayType -> Flow Graph ArrayType
forall a. a -> Flow Graph a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (ArrayType -> Flow Graph ArrayType)
-> ArrayType -> Flow Graph ArrayType
forall a b. (a -> b) -> a -> b
$
      Dims -> ArrayType_Variant -> ArrayType
Java.ArrayType ([[Annotation]] -> Dims
Java.Dims ([[Annotation]] -> Dims) -> [[Annotation]] -> Dims
forall a b. (a -> b) -> a -> b
$ [[Annotation]]
d [[Annotation]] -> [[Annotation]] -> [[Annotation]]
forall a. [a] -> [a] -> [a]
++ [[]]) ArrayType_Variant
v
    ReferenceType
_ -> String -> Flow Graph ArrayType
forall a. String -> Flow Graph a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> Flow Graph ArrayType) -> String -> Flow Graph ArrayType
forall a b. (a -> b) -> a -> b
$ String
"don't know how to make Java reference type into array type: " String -> ShowS
forall a. [a] -> [a] -> [a]
++ ReferenceType -> String
forall a. Show a => a -> String
show ReferenceType
rt
  Type
_ -> String -> Flow Graph ArrayType
forall a. String -> Flow Graph a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> Flow Graph ArrayType) -> String -> Flow Graph ArrayType
forall a b. (a -> b) -> a -> b
$ String
"don't know how to make Java type into array type: " String -> ShowS
forall a. [a] -> [a] -> [a]
++ Type -> String
forall a. Show a => a -> String
show Type
t

typeParameterToTypeArgument :: Java.TypeParameter -> Java.TypeArgument
typeParameterToTypeArgument :: TypeParameter -> TypeArgument
typeParameterToTypeArgument (Java.TypeParameter [TypeParameterModifier]
_ TypeIdentifier
id Maybe TypeBound
_) = TypeIdentifier -> TypeArgument
javaTypeIdentifierToJavaTypeArgument TypeIdentifier
id

typeParameterToReferenceType :: Java.TypeParameter -> Java.ReferenceType
typeParameterToReferenceType :: TypeParameter -> ReferenceType
typeParameterToReferenceType = String -> ReferenceType
javaTypeVariable (String -> ReferenceType)
-> (TypeParameter -> String) -> TypeParameter -> ReferenceType
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TypeParameter -> String
unTypeParameter

unTypeParameter :: Java.TypeParameter -> String
unTypeParameter :: TypeParameter -> String
unTypeParameter (Java.TypeParameter [] (Java.TypeIdentifier (Java.Identifier String
v)) Maybe TypeBound
Nothing) = String
v

unescape :: String -> String
unescape :: ShowS
unescape = ShowS
forall a. HasCallStack => [a] -> [a]
L.tail

variableDeclarationStatement :: Aliases -> Java.Type -> Java.Identifier -> Java.Expression -> Java.BlockStatement
variableDeclarationStatement :: Aliases -> Type -> Identifier -> Expression -> BlockStatement
variableDeclarationStatement Aliases
aliases Type
jtype Identifier
id Expression
rhs = LocalVariableDeclarationStatement -> BlockStatement
Java.BlockStatementLocalVariableDeclaration (LocalVariableDeclarationStatement -> BlockStatement)
-> LocalVariableDeclarationStatement -> BlockStatement
forall a b. (a -> b) -> a -> b
$
    LocalVariableDeclaration -> LocalVariableDeclarationStatement
Java.LocalVariableDeclarationStatement (LocalVariableDeclaration -> LocalVariableDeclarationStatement)
-> LocalVariableDeclaration -> LocalVariableDeclarationStatement
forall a b. (a -> b) -> a -> b
$ [VariableModifier]
-> LocalVariableType
-> [VariableDeclarator]
-> LocalVariableDeclaration
Java.LocalVariableDeclaration [] (UnannType -> LocalVariableType
Java.LocalVariableTypeType (UnannType -> LocalVariableType) -> UnannType -> LocalVariableType
forall a b. (a -> b) -> a -> b
$ Type -> UnannType
Java.UnannType Type
jtype) [VariableDeclarator
vdec]
  where
    vdec :: VariableDeclarator
vdec = Identifier -> Maybe VariableInitializer -> VariableDeclarator
javaVariableDeclarator Identifier
id (VariableInitializer -> Maybe VariableInitializer
forall a. a -> Maybe a
Just VariableInitializer
init)
      where
        init :: VariableInitializer
init = Expression -> VariableInitializer
Java.VariableInitializerExpression Expression
rhs

variableToJavaIdentifier :: Name -> Java.Identifier
variableToJavaIdentifier :: Name -> Identifier
variableToJavaIdentifier (Name String
var) = String -> Identifier
Java.Identifier (String -> Identifier) -> String -> Identifier
forall a b. (a -> b) -> a -> b
$ if String
var String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
ignoredVariable
  then String
"ignored"
  else String
var -- TODO: escape

variantClassName :: Bool -> Name -> Name -> Name
variantClassName :: Bool -> Name -> Name -> Name
variantClassName Bool
qualify Name
elName (Name String
fname) = QualifiedName -> Name
unqualifyName (Maybe Namespace -> String -> QualifiedName
QualifiedName Maybe Namespace
ns String
local1)
  where
    QualifiedName Maybe Namespace
ns String
local = Name -> QualifiedName
qualifyNameEager Name
elName
    flocal :: String
flocal = ShowS
capitalize String
fname
    local1 :: String
local1 = if Bool
qualify
      then String
local String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
"." String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
flocal
      else if String
flocal String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
local then String
flocal String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
"_" else String
flocal

visitorTypeVariable :: Java.ReferenceType
visitorTypeVariable :: ReferenceType
visitorTypeVariable = String -> ReferenceType
javaTypeVariable String
"r"