---
Function {
    argument: None,
    arguments: FunctionArguments {
        arguments: [
            FunctionArgument {
                identifier: "jre",
                default: None,
            },
            FunctionArgument {
                identifier: "unzip",
                default: None,
            },
            FunctionArgument {
                identifier: "fetchurl",
                default: None,
            },
            FunctionArgument {
                identifier: "lib",
                default: None,
            },
            FunctionArgument {
                identifier: "stdenv",
                default: None,
            },
        ],
        ellipsis: false,
    },
    definition: LetIn {
        bindings: [
            KeyValue(
                AttributePath {
                    attributes: [
                        Raw {
                            content: "version",
                            position: (5, 3),
                        },
                    ],
                },
                String {
                    parts: [
                        Raw {
                            content: "4.7.0.2747",
                            position: (5, 14),
                        },
                    ],
                },
            ),
            KeyValue(
                AttributePath {
                    attributes: [
                        Raw {
                            content: "sonarScannerArchPackage",
                            position: (7, 3),
                        },
                    ],
                },
                Map {
                    bindings: [
                        KeyValue(
                            AttributePath {
                                attributes: [
                                    Expression {
                                        expression: String {
                                            parts: [
                                                Raw {
                                                    content: "x86_64-linux",
                                                    position: (8, 6),
                                                },
                                            ],
                                        },
                                    },
                                ],
                            },
                            Map {
                                bindings: [
                                    KeyValue(
                                        AttributePath {
                                            attributes: [
                                                Raw {
                                                    content: "url",
                                                    position: (9, 7),
                                                },
                                            ],
                                        },
                                        String {
                                            parts: [
                                                Raw {
                                                    content: "https://binaries.sonarsource.com/Distribution/sonar-scanner-cli/sonar-scanner-cli-",
                                                    position: (9, 14),
                                                },
                                                Expression {
                                                    expression: Variable {
                                                        identifier: "version",
                                                        position: (9, 98),
                                                    },
                                                },
                                                Raw {
                                                    content: "-linux.zip",
                                                    position: (9, 106),
                                                },
                                            ],
                                        },
                                    ),
                                    KeyValue(
                                        AttributePath {
                                            attributes: [
                                                Raw {
                                                    content: "sha256",
                                                    position: (10, 7),
                                                },
                                            ],
                                        },
                                        String {
                                            parts: [
                                                Raw {
                                                    content: "0qy97lcn9nfwg0x32v9x5kh5jswnjyw3wpvxj45z7cddlj2is4iy",
                                                    position: (10, 17),
                                                },
                                            ],
                                        },
                                    ),
                                ],
                                recursive: false,
                            },
                        ),
                        KeyValue(
                            AttributePath {
                                attributes: [
                                    Expression {
                                        expression: String {
                                            parts: [
                                                Raw {
                                                    content: "x86_64-darwin",
                                                    position: (12, 6),
                                                },
                                            ],
                                        },
                                    },
                                ],
                            },
                            Map {
                                bindings: [
                                    KeyValue(
                                        AttributePath {
                                            attributes: [
                                                Raw {
                                                    content: "url",
                                                    position: (13, 7),
                                                },
                                            ],
                                        },
                                        String {
                                            parts: [
                                                Raw {
                                                    content: "https://binaries.sonarsource.com/Distribution/sonar-scanner-cli/sonar-scanner-cli-",
                                                    position: (13, 14),
                                                },
                                                Expression {
                                                    expression: Variable {
                                                        identifier: "version",
                                                        position: (13, 98),
                                                    },
                                                },
                                                Raw {
                                                    content: "-macosx.zip",
                                                    position: (13, 106),
                                                },
                                            ],
                                        },
                                    ),
                                    KeyValue(
                                        AttributePath {
                                            attributes: [
                                                Raw {
                                                    content: "sha256",
                                                    position: (14, 7),
                                                },
                                            ],
                                        },
                                        String {
                                            parts: [
                                                Raw {
                                                    content: "0f8km7wqkw09g01l03kcrjgvq7b6xclzpvb5r64ymsmrc39p0ylp",
                                                    position: (14, 17),
                                                },
                                            ],
                                        },
                                    ),
                                ],
                                recursive: false,
                            },
                        ),
                    ],
                    recursive: false,
                },
            ),
        ],
        target: FunctionApplication {
            function: PropertyAccess {
                expression: Variable {
                    identifier: "stdenv",
                    position: (18, 4),
                },
                attribute_path: AttributePath {
                    attributes: [
                        Raw {
                            content: "mkDerivation",
                            position: (18, 11),
                        },
                    ],
                },
                default: None,
            },
            arguments: [
                Map {
                    bindings: [
                        Inherit(
                            None,
                            [
                                Raw {
                                    content: "version",
                                    position: (19, 11),
                                },
                            ],
                        ),
                        KeyValue(
                            AttributePath {
                                attributes: [
                                    Raw {
                                        content: "pname",
                                        position: (20, 3),
                                    },
                                ],
                            },
                            String {
                                parts: [
                                    Raw {
                                        content: "sonar-scanner-cli",
                                        position: (20, 12),
                                    },
                                ],
                            },
                        ),
                        KeyValue(
                            AttributePath {
                                attributes: [
                                    Raw {
                                        content: "src",
                                        position: (22, 3),
                                    },
                                ],
                            },
                            FunctionApplication {
                                function: Variable {
                                    identifier: "fetchurl",
                                    position: (22, 9),
                                },
                                arguments: [
                                    PropertyAccess {
                                        expression: Variable {
                                            identifier: "sonarScannerArchPackage",
                                            position: (22, 18),
                                        },
                                        attribute_path: AttributePath {
                                            attributes: [
                                                Expression {
                                                    expression: PropertyAccess {
                                                        expression: Variable {
                                                            identifier: "stdenv",
                                                            position: (22, 44),
                                                        },
                                                        attribute_path: AttributePath {
                                                            attributes: [
                                                                Raw {
                                                                    content: "hostPlatform",
                                                                    position: (22, 51),
                                                                },
                                                                Raw {
                                                                    content: "system",
                                                                    position: (22, 64),
                                                                },
                                                            ],
                                                        },
                                                        default: None,
                                                    },
                                                },
                                            ],
                                        },
                                        default: None,
                                    },
                                ],
                            },
                        ),
                        KeyValue(
                            AttributePath {
                                attributes: [
                                    Raw {
                                        content: "nativeBuildInputs",
                                        position: (24, 3),
                                    },
                                ],
                            },
                            List {
                                elements: [
                                    Variable {
                                        identifier: "unzip",
                                        position: (24, 25),
                                    },
                                ],
                            },
                        ),
                        KeyValue(
                            AttributePath {
                                attributes: [
                                    Raw {
                                        content: "installPhase",
                                        position: (26, 3),
                                    },
                                ],
                            },
                            String {
                                parts: [
                                    Raw {
                                        content: "mkdir -p $out/lib\ncp -r lib/* $out/lib/\nmkdir -p $out/bin\ncp bin/* $out/bin/\nmkdir -p $out/conf\ncp conf/* $out/conf/\n",
                                        position: (27, 1),
                                    },
                                ],
                            },
                        ),
                        KeyValue(
                            AttributePath {
                                attributes: [
                                    Raw {
                                        content: "fixupPhase",
                                        position: (35, 3),
                                    },
                                ],
                            },
                            String {
                                parts: [
                                    Raw {
                                        content: "substituteInPlace $out/bin/sonar-scanner \\\n  --replace \"\\$sonar_scanner_home/jre\" \"",
                                        position: (36, 1),
                                    },
                                    Expression {
                                        expression: FunctionApplication {
                                            function: PropertyAccess {
                                                expression: Variable {
                                                    identifier: "lib",
                                                    position: (37, 47),
                                                },
                                                attribute_path: AttributePath {
                                                    attributes: [
                                                        Raw {
                                                            content: "getBin",
                                                            position: (37, 51),
                                                        },
                                                    ],
                                                },
                                                default: None,
                                            },
                                            arguments: [
                                                Variable {
                                                    identifier: "jre",
                                                    position: (37, 58),
                                                },
                                            ],
                                        },
                                    },
                                    Raw {
                                        content: "\"\n",
                                        position: (37, 62),
                                    },
                                ],
                            },
                        ),
                        KeyValue(
                            AttributePath {
                                attributes: [
                                    Raw {
                                        content: "meta",
                                        position: (40, 3),
                                    },
                                ],
                            },
                            With {
                                expression: Variable {
                                    identifier: "lib",
                                    position: (40, 15),
                                },
                                target: Map {
                                    bindings: [
                                        KeyValue(
                                            AttributePath {
                                                attributes: [
                                                    Raw {
                                                        content: "homepage",
                                                        position: (41, 5),
                                                    },
                                                ],
                                            },
                                            String {
                                                parts: [
                                                    Raw {
                                                        content: "https://github.com/SonarSource/sonar-scanner-cli",
                                                        position: (41, 17),
                                                    },
                                                ],
                                            },
                                        ),
                                        KeyValue(
                                            AttributePath {
                                                attributes: [
                                                    Raw {
                                                        content: "description",
                                                        position: (42, 5),
                                                    },
                                                ],
                                            },
                                            String {
                                                parts: [
                                                    Raw {
                                                        content: "SonarQube Scanner used to start code analysis",
                                                        position: (42, 20),
                                                    },
                                                ],
                                            },
                                        ),
                                        KeyValue(
                                            AttributePath {
                                                attributes: [
                                                    Raw {
                                                        content: "license",
                                                        position: (43, 5),
                                                    },
                                                ],
                                            },
                                            PropertyAccess {
                                                expression: Variable {
                                                    identifier: "licenses",
                                                    position: (43, 15),
                                                },
                                                attribute_path: AttributePath {
                                                    attributes: [
                                                        Raw {
                                                            content: "gpl3Plus",
                                                            position: (43, 24),
                                                        },
                                                    ],
                                                },
                                                default: None,
                                            },
                                        ),
                                        KeyValue(
                                            AttributePath {
                                                attributes: [
                                                    Raw {
                                                        content: "maintainers",
                                                        position: (44, 5),
                                                    },
                                                ],
                                            },
                                            With {
                                                expression: Variable {
                                                    identifier: "maintainers",
                                                    position: (44, 24),
                                                },
                                                target: List {
                                                    elements: [
                                                        Variable {
                                                            identifier: "peterromfeldhk",
                                                            position: (44, 39),
                                                        },
                                                    ],
                                                },
                                            },
                                        ),
                                        KeyValue(
                                            AttributePath {
                                                attributes: [
                                                    Raw {
                                                        content: "platforms",
                                                        position: (45, 5),
                                                    },
                                                ],
                                            },
                                            FunctionApplication {
                                                function: PropertyAccess {
                                                    expression: Variable {
                                                        identifier: "builtins",
                                                        position: (45, 17),
                                                    },
                                                    attribute_path: AttributePath {
                                                        attributes: [
                                                            Raw {
                                                                content: "attrNames",
                                                                position: (45, 26),
                                                            },
                                                        ],
                                                    },
                                                    default: None,
                                                },
                                                arguments: [
                                                    Variable {
                                                        identifier: "sonarScannerArchPackage",
                                                        position: (45, 36),
                                                    },
                                                ],
                                            },
                                        ),
                                    ],
                                    recursive: false,
                                },
                            },
                        ),
                    ],
                    recursive: true,
                },
            ],
        },
    },
}