dest = growBuffer(dest, destIndex, destSize);
      }

      // If we have skipped any characters, we need to copy them now.
      if (charsSkipped > 0) {
        s.getChars(lastEscape, index, dest, destIndex);
        destIndex += charsSkipped;
      }

      // Copy the replacement string into the dest buffer as needed.
      if (rlen > 0) {

        return description;
    }

    public LaunchableGradleTask setDescription(String description) {
        this.description = description;
        return this;
    }

    @Override
    public List<String> getArgs() {
        return Collections.singletonList(path);
    }

    @Override
    public String getProjectPath() {
        return null;
    }

    public String getGroup() {
        return group;
    }

        symbol_table.lookup(GetEntryFunctionName(op)));
    if (!entry_func_op) return failure();

    // Replace the XlaCallModuleOp with a new CallOp.
    rewriter.replaceOpWithNewOp<func::CallOp>(op, entry_func_op, op.getArgs());
    return success();
  }
};

void XlaCallModuleToCallPass::runOnOperation() {
  ModuleOp module_op = getOperation();
  MLIRContext* ctx = module_op.getContext();
  RewritePatternSet patterns(&getContext());

            }
"""
        file("src/other/cpp/func2.cpp") << """
            int getTwo();

            int func2() {
                return getTwo();
            }
"""
        file("src/lib1/cpp/getters.cpp") << """
            int getOne() {
                return 1;
            }
            int getTwo() {
                return 2;
            }
"""

        and:
        buildFile << """

        }
    };

    private static final DescribedPredicate<JavaClass> injected_by_getter = new DescribedPredicate<JavaClass>("injected into getters via @Inject") {
        @Override
        public boolean test(JavaClass javaClass) {
            return javaClass
                .getMethodsWithReturnTypeOfSelf()
                .stream()

        visitFailures(results1) == []
        visitFailures(results2) == [throwable]
        visitFailures(results3) == [resolveEx]
        visitFailures(results4) == [throwable, resolveEx]
    }

    def "getters return the values passed to the constructor"() {
        given:
        def resolveEx = Mock(ResolveException)
        def unresolved = Mock(UnresolvedDependency)

            }
            if (!spec.getLibraryPath().isEmpty()) {
                throw new UnsupportedOperationException("Library Path not yet supported on Swiftc");
            }

            for (String userArg : spec.getArgs()) {
                args.add(userArg);
            }

            return args;
        }
    }

     * @return this
     */
    ExecSpec setArgs(Iterable<?> args);

    /**
     * Returns the arguments for the command to be executed. Defaults to an empty list.
     */
    List<String> getArgs();

    /**
     * Argument providers for the application.
     *
     * @since 4.6
     */
    List<CommandLineArgumentProvider> getArgumentProviders();

        if (invocation.getWorkDirectory() != null) {
            GFileUtils.mkdirs(invocation.getWorkDirectory());
            toolExec.workingDir(invocation.getWorkDirectory());
        }

        toolExec.args(invocation.getArgs());

        if (!invocation.getPath().isEmpty()) {
            String pathVar = OperatingSystem.current().getPathVar();
            String toolPath = Joiner.on(File.pathSeparator).join(invocation.getPath());

                                PatternRewriter& rewriter) const override {
    auto preceding_qcast =
        q_op.getArg().getDefiningOp<quantfork::QuantizeCastOp>();
    if (!preceding_qcast) return failure();

    auto new_qcast = rewriter.create<quantfork::QuantizeCastOp>(
        q_op.getLoc(), q_op.getType(), preceding_qcast.getArg());
    new_qcast->setAttr(kVolatileOpAttrName, rewriter.getUnitAttr());
    q_op->replaceAllUsesWith(new_qcast);