public DefaultTypeCoercerFactory()

in src/com/facebook/buck/rules/coercer/DefaultTypeCoercerFactory.java [98:346]


  public DefaultTypeCoercerFactory() {
    StringTypeCoercer stringTypeCoercer = new StringTypeCoercer();
    TypeCoercer<Flavor, Flavor> flavorTypeCoercer = new FlavorTypeCoercer();
    // This has no implementation, but is here so that constructor succeeds so that it can be
    // queried. This is only used for the visibility field, which is not actually handled by the
    // coercer.
    TypeCoercer<BuildTargetMatcher, BuildTargetMatcher> buildTargetPatternTypeCoercer =
        new BuildTargetMatcherTypeCoercer();
    unconfiguredBuildTargetFactory = new ParsingUnconfiguredBuildTargetViewFactory();
    unconfiguredBuildTargetTypeCoercer =
        new UnconfiguredBuildTargetTypeCoercer(unconfiguredBuildTargetFactory);
    BuildTargetTypeCoercer buildTargetTypeCoercer =
        new BuildTargetTypeCoercer(unconfiguredBuildTargetTypeCoercer);
    BuildTargetWithOutputsTypeCoercer buildTargetWithOutputsTypeCoercer =
        new BuildTargetWithOutputsTypeCoercer(
            new UnconfiguredBuildTargetWithOutputsTypeCoercer(unconfiguredBuildTargetTypeCoercer));
    TypeCoercer<Path, Path> pathTypeCoercer = new PathTypeCoercer();
    TypeCoercer<UnconfiguredSourcePath, SourcePath> sourcePathTypeCoercer =
        new SourcePathTypeCoercer(buildTargetWithOutputsTypeCoercer, pathTypeCoercer);
    TypeCoercer<Object, SourceWithFlags> sourceWithFlagsTypeCoercer =
        new SourceWithFlagsTypeCoercer(
            sourcePathTypeCoercer, new ListTypeCoercer<>(stringTypeCoercer));
    TypeCoercer<Integer, Integer> intTypeCoercer = new NumberTypeCoercer<>(Integer.class);
    TypeCoercer<Double, Double> doubleTypeCoercer = new NumberTypeCoercer<>(Double.class);
    TypeCoercer<Boolean, Boolean> booleanTypeCoercer = new IdentityTypeCoercer<>(Boolean.class);
    TypeCoercer<Object, NeededCoverageSpec> neededCoverageSpecTypeCoercer =
        new NeededCoverageSpecTypeCoercer(
            intTypeCoercer, buildTargetTypeCoercer, stringTypeCoercer);
    TypeCoercer<Object, Query> queryTypeCoercer =
        new QueryCoercer(this, unconfiguredBuildTargetFactory);
    TypeCoercer<ImmutableList<UnconfiguredBuildTarget>, ImmutableList<BuildTarget>>
        buildTargetsTypeCoercer = new ListTypeCoercer<>(buildTargetTypeCoercer);
    TypeCoercer<Object, CxxLinkGroupMappingTarget.Traversal> linkGroupMappingTraversalCoercer =
        new CxxLinkGroupMappingTargetTraversalCoercer();
    TypeCoercer<Object, CxxLinkGroupMappingTarget> linkGroupMappingTargetCoercer =
        new CxxLinkGroupMappingTargetCoercer(
            buildTargetTypeCoercer, linkGroupMappingTraversalCoercer, patternTypeCoercer);
    TypeCoercer<ImmutableList<Object>, ImmutableList<CxxLinkGroupMappingTarget>>
        linkGroupMappingTargetsCoercer = new ListTypeCoercer<>(linkGroupMappingTargetCoercer);
    TypeCoercer<Object, CxxLinkGroupMapping> linkGroupMappingCoercer =
        new CxxLinkGroupMappingCoercer(stringTypeCoercer, linkGroupMappingTargetsCoercer);
    TypeCoercer<Object, StringWithMacros> stringWithMacrosCoercer =
        StringWithMacrosTypeCoercer.builder()
            .put(
                "classpath",
                ClasspathMacro.class,
                new BuildTargetMacroTypeCoercer<>(
                    buildTargetWithOutputsTypeCoercer,
                    ClasspathMacro.class,
                    BuildTargetMacroTypeCoercer.TargetOrHost.TARGET,
                    ClasspathMacro::of))
            .put(
                "classpath_abi",
                ClasspathAbiMacro.class,
                new BuildTargetMacroTypeCoercer<>(
                    buildTargetWithOutputsTypeCoercer,
                    ClasspathAbiMacro.class,
                    BuildTargetMacroTypeCoercer.TargetOrHost.TARGET,
                    ClasspathAbiMacro::of))
            .put(
                "exe",
                ExecutableMacro.class,
                new BuildTargetMacroTypeCoercer<>(
                    buildTargetWithOutputsTypeCoercer,
                    ExecutableMacro.class,
                    // TODO(nga): switch to host
                    BuildTargetMacroTypeCoercer.TargetOrHost.TARGET,
                    ExecutableMacro::of))
            .put(
                "exe_target",
                ExecutableTargetMacro.class,
                new BuildTargetMacroTypeCoercer<>(
                    buildTargetWithOutputsTypeCoercer,
                    ExecutableTargetMacro.class,
                    BuildTargetMacroTypeCoercer.TargetOrHost.TARGET,
                    ExecutableTargetMacro::of))
            .put("env", EnvMacro.class, new EnvMacroTypeCoercer())
            .put(
                "location",
                LocationMacro.class,
                new LocationMacroTypeCoercer(buildTargetWithOutputsTypeCoercer))
            .put(
                "location-platform",
                LocationPlatformMacro.class,
                new LocationPlatformMacroTypeCoercer(buildTargetWithOutputsTypeCoercer))
            .put(
                "maven_coords",
                MavenCoordinatesMacro.class,
                new BuildTargetMacroTypeCoercer<>(
                    buildTargetWithOutputsTypeCoercer,
                    MavenCoordinatesMacro.class,
                    BuildTargetMacroTypeCoercer.TargetOrHost.TARGET,
                    MavenCoordinatesMacro::of))
            .put("output", OutputMacro.class, new OutputMacroTypeCoercer())
            .put("abs_output", AbsoluteOutputMacro.class, new AbsoluteOutputMacroTypeCoercer())
            .put(
                "query_targets",
                QueryTargetsMacro.class,
                new QueryMacroTypeCoercer<>(
                    queryTypeCoercer, QueryTargetsMacro.class, QueryTargetsMacro::of))
            .put(
                "query_outputs",
                QueryOutputsMacro.class,
                new QueryMacroTypeCoercer<>(
                    queryTypeCoercer, QueryOutputsMacro.class, QueryOutputsMacro::of))
            .put(
                "query_paths",
                QueryPathsMacro.class,
                new QueryMacroTypeCoercer<>(
                    queryTypeCoercer, QueryPathsMacro.class, QueryPathsMacro::of))
            .put(
                "query_targets_and_outputs",
                QueryTargetsAndOutputsMacro.class,
                new QueryTargetsAndOutputsMacroTypeCoercer(queryTypeCoercer))
            .put(
                "worker",
                WorkerMacro.class,
                new BuildTargetMacroTypeCoercer<>(
                    buildTargetWithOutputsTypeCoercer,
                    WorkerMacro.class,
                    BuildTargetMacroTypeCoercer.TargetOrHost.TARGET,
                    WorkerMacro::of))
            .put("cc", CcMacro.class, new ZeroArgMacroTypeCoercer<>(CcMacro.class, CcMacro.of()))
            .put(
                "cflags",
                CcFlagsMacro.class,
                new ZeroArgMacroTypeCoercer<>(CcFlagsMacro.class, CcFlagsMacro.of()))
            .put(
                "cppflags",
                CppFlagsMacro.class,
                new CxxGenruleFilterAndTargetsMacroTypeCoercer<>(
                    Optional.empty(),
                    buildTargetsTypeCoercer,
                    CppFlagsMacro.class,
                    CppFlagsMacro::of))
            .put(
                "cxx", CxxMacro.class, new ZeroArgMacroTypeCoercer<>(CxxMacro.class, CxxMacro.of()))
            .put(
                "cxxflags",
                CxxFlagsMacro.class,
                new ZeroArgMacroTypeCoercer<>(CxxFlagsMacro.class, CxxFlagsMacro.of()))
            .put(
                "cxxppflags",
                CxxppFlagsMacro.class,
                new CxxGenruleFilterAndTargetsMacroTypeCoercer<>(
                    Optional.empty(),
                    buildTargetsTypeCoercer,
                    CxxppFlagsMacro.class,
                    CxxppFlagsMacro::of))
            .put("ld", LdMacro.class, new ZeroArgMacroTypeCoercer<>(LdMacro.class, LdMacro.of()))
            .put(
                "ldflags-shared",
                LdflagsSharedMacro.class,
                new CxxGenruleFilterAndTargetsMacroTypeCoercer<>(
                    Optional.empty(),
                    buildTargetsTypeCoercer,
                    LdflagsSharedMacro.class,
                    LdflagsSharedMacro::of))
            .put(
                "ldflags-shared-filter",
                LdflagsSharedFilterMacro.class,
                new CxxGenruleFilterAndTargetsMacroTypeCoercer<>(
                    Optional.of(patternTypeCoercer),
                    buildTargetsTypeCoercer,
                    LdflagsSharedFilterMacro.class,
                    LdflagsSharedFilterMacro::of))
            .put(
                "ldflags-static",
                LdflagsStaticMacro.class,
                new CxxGenruleFilterAndTargetsMacroTypeCoercer<>(
                    Optional.empty(),
                    buildTargetsTypeCoercer,
                    LdflagsStaticMacro.class,
                    LdflagsStaticMacro::of))
            .put(
                "ldflags-static-filter",
                LdflagsStaticFilterMacro.class,
                new CxxGenruleFilterAndTargetsMacroTypeCoercer<>(
                    Optional.of(patternTypeCoercer),
                    buildTargetsTypeCoercer,
                    LdflagsStaticFilterMacro.class,
                    LdflagsStaticFilterMacro::of))
            .put(
                "ldflags-static-pic",
                LdflagsStaticPicMacro.class,
                new CxxGenruleFilterAndTargetsMacroTypeCoercer<>(
                    Optional.empty(),
                    buildTargetsTypeCoercer,
                    LdflagsStaticPicMacro.class,
                    LdflagsStaticPicMacro::of))
            .put(
                "ldflags-static-pic-filter",
                LdflagsStaticPicFilterMacro.class,
                new CxxGenruleFilterAndTargetsMacroTypeCoercer<>(
                    Optional.of(patternTypeCoercer),
                    buildTargetsTypeCoercer,
                    LdflagsStaticPicFilterMacro.class,
                    LdflagsStaticPicFilterMacro::of))
            .put(
                "platform-name",
                PlatformNameMacro.class,
                new ZeroArgMacroTypeCoercer<>(PlatformNameMacro.class, PlatformNameMacro.of()))
            .build();
    nonParameterizedTypeCoercers =
        (TypeCoercer<Object, ?>[])
            new TypeCoercer<?, ?>[] {
              // special classes
              pathTypeCoercer,
              flavorTypeCoercer,
              sourcePathTypeCoercer,
              unconfiguredBuildTargetTypeCoercer,
              buildTargetTypeCoercer,
              buildTargetWithOutputsTypeCoercer,
              buildTargetPatternTypeCoercer,

              // apple link groups
              linkGroupMappingCoercer,

              // identity
              stringTypeCoercer,
              booleanTypeCoercer,

              // numeric
              intTypeCoercer,
              doubleTypeCoercer,
              new NumberTypeCoercer<>(Float.class),
              new NumberTypeCoercer<>(Long.class),
              new NumberTypeCoercer<>(Short.class),
              new NumberTypeCoercer<>(Byte.class),

              // other simple
              sourceWithFlagsTypeCoercer,
              new BuildConfigFieldsTypeCoercer(),
              new UriTypeCoercer(),
              new FrameworkPathTypeCoercer(sourcePathTypeCoercer),
              new SourceWithFlagsListTypeCoercer(stringTypeCoercer, sourceWithFlagsTypeCoercer),
              new SourceSetTypeCoercer(stringTypeCoercer, sourcePathTypeCoercer),
              new SourceSortedSetTypeCoercer(stringTypeCoercer, sourcePathTypeCoercer),
              new LogLevelTypeCoercer(),
              new ManifestEntriesTypeCoercer(),
              patternTypeCoercer,
              neededCoverageSpecTypeCoercer,
              new ConstraintTypeCoercer(),
              new VersionTypeCoercer(),
              queryTypeCoercer,
              stringWithMacrosCoercer,
              new TestRunnerSpecCoercer(stringWithMacrosCoercer),
            };
  }