return f.abs
}

func (f *outputdirFlag) Set(value string) (err error) {
	if value == "" {
		f.abs = ""
	} else {
		f.abs, err = filepath.Abs(value)
	}
	return err
}

func (f *outputdirFlag) getAbs() string {
	if f.abs == "" {
		return base.Cwd()
	}
	return f.abs
}

// vetFlag implements the special parsing logic for the -vet flag:
// a comma-separated list, with distinguished values "all" and

                        for (SourceSet sourceSet : project.getExtensions().getByType(JavaPluginExtension.class).getSourceSets()) {
                            result.addAll(sourceSet.getOutput().getDirs().getFiles());
                        }
                        return result;
                    }
                });

                task.configure(new Action<GenerateEclipseClasspath>() {

    private static class SwiftCompileArgsTransformer implements ArgsTransformer<SwiftCompileSpec> {
        @Override
        public List<String> transform(SwiftCompileSpec swiftCompileSpec) {
            return swiftCompileSpec.getArgs();
        }
    }

    private static class OutputFileMap {
        private Map<String, Entry> entries = new HashMap<String, Entry>();

        public Builder root() {
            return newEntry("");

                                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);

 * In both cases, the implementation of the calculated property getter may not call any setter method.
 *
 * <h3>Abstract classes</h3>
 * <p>
 * A managed type can be implemented as an abstract class.
 * All property getters and setters must be declared {@code abstract} (with the exception of calculated read-only properties).
 * The class cannot contain instance variables, constructors, or any methods that are not a getter or setter.
 *

	return file_pkg_test_config_mock_config_proto_rawDescGZIP(), []int{0}
}

func (x *MockConfig) GetKey() string {
	if x != nil {
		return x.Key
	}
	return ""
}

func (x *MockConfig) GetPairs() []*ConfigPair {
	if x != nil {
		return x.Pairs
	}
	return nil
}

type ConfigPair struct {
	state         protoimpl.MessageState
	sizeCache     protoimpl.SizeCache
	unknownFields protoimpl.UnknownFields

                contextualLabel == 'Type \'MyTask\' property \'badTime\' is private and annotated with @Input'
                details == 'Annotations on private getters are ignored'
                solutions == [
                    'Make the getter public',
                    'Annotate the public version of the getter',
                ]
                additionalData.asMap == [

        defines.addAll(getDefines("rcCompiler"));
        return defines;
    }

    @Override
    public LanguageStandard getLanguageStandard() {
        return LanguageStandard.from(binary.getCppCompiler().getArgs());
    }

    private List<String> getDefines(String tool) {
        PreprocessingTool rcCompiler = findCompiler(tool);

  // Finds the mapping from a replicate argument to an execute operand.
  llvm::SmallDenseMap<int64_t, int64_t, 8> replicate_arg_to_execute_arg;
  for (auto index_and_arg : llvm::enumerate(execute.getArgs())) {
    auto arg = SkipIdentity(index_and_arg.value(), /*allow_other_use=*/false);
    if (!arg.hasOneUse() ||
        !mlir::isa<TF::ResourceType>(getElementTypeOrSelf(arg.getType()))) {
      continue;
    }

        bean.CCompiler = 'upper-case first char'
        bean.cppCompiler = 'cppCompiler'
        bean.CPPCompiler = 'CPPCompiler'
        bean.a = 'some a'
        bean.b = 'some b'

        then:
        // Exercise getters
        bean.url == 'lower-case' && bean.getUrl() == bean.url
        bean.URL == 'upper-case' && bean.getURL() == bean.URL
        bean.cCompiler == 'lower-case first char' && bean.getcCompiler() == bean.cCompiler