let skipDefaultBuilders = 1;
let builders = [
OpBuilder<(ins "int64_t":$lowerBound, "int64_t":$upperBound,
- CArg<"int64_t", "1">:$step, CArg<"ValueRange", "llvm::None">:$iterArgs,
+ CArg<"int64_t", "1">:$step, CArg<"ValueRange", "std::nullopt">:$iterArgs,
CArg<"function_ref<void(OpBuilder &, Location, Value, ValueRange)>",
"nullptr">:$bodyBuilder)>,
OpBuilder<(ins "ValueRange":$lbOperands, "AffineMap":$lbMap,
"ValueRange":$ubOperands, "AffineMap":$ubMap, CArg<"int64_t", "1">:$step,
- CArg<"ValueRange", "llvm::None">:$iterArgs,
+ CArg<"ValueRange", "std::nullopt">:$iterArgs,
CArg<"function_ref<void(OpBuilder &, Location, Value, ValueRange)>",
"nullptr">:$bodyBuilder)>
];
let arguments = (ins Variadic<AnyType>:$operands);
let builders = [
- OpBuilder<(ins), [{ build($_builder, $_state, llvm::None); }]>
+ OpBuilder<(ins), [{ build($_builder, $_state, std::nullopt); }]>
];
let assemblyFormat = "attr-dict ($operands^ `:` type($operands))?";
let arguments = (ins Variadic<AnyType>:$operands);
- let builders = [OpBuilder<(ins), [{build($_builder, $_state, llvm::None);}]>];
+ let builders = [OpBuilder<(ins), [{build($_builder, $_state, std::nullopt);}]>];
let assemblyFormat = "attr-dict ($operands^ `:` type($operands))?";
let hasVerifier = 1;
let extraClassDeclaration = [{
Optional<Type> getResultType() {
- if (getResultTypes().empty()) return None;
+ if (getResultTypes().empty()) return std::nullopt;
return getResultTypes()[0];
}
}];
}],
"::mlir::Optional<::mlir::Operation*>", "buildDealloc",
(ins "::mlir::OpBuilder&":$builder, "::mlir::Value":$alloc), [{}],
- /*defaultImplementation=*/[{ return llvm::None; }]
+ /*defaultImplementation=*/[{ return std::nullopt; }]
>,
StaticInterfaceMethod<[{
Builds a clone operation using the provided builder and the current
}],
"::mlir::Optional<::mlir::Value>", "buildClone",
(ins "::mlir::OpBuilder&":$builder, "::mlir::Value":$alloc), [{}],
- /*defaultImplementation=*/[{ return llvm::None; }]
+ /*defaultImplementation=*/[{ return std::nullopt; }]
>
];
}
let arguments = (ins Variadic<AnyType>:$operands);
let builders = [OpBuilder<(ins), [{
- build($_builder, $_state, llvm::None);
+ build($_builder, $_state, std::nullopt);
}]>];
let assemblyFormat = "attr-dict ($operands^ `:` type($operands))?";
llvm::MetadataAsValue::get(ctx,
llvm::ValueAsMetadata::get(moduleTranslation.lookupValue(opInst.getOperand(0)))),
llvm::MetadataAsValue::get(ctx, moduleTranslation.translateDebugInfo($varInfo)),
- llvm::MetadataAsValue::get(ctx, llvm::DIExpression::get(ctx, llvm::None)),
+ llvm::MetadataAsValue::get(ctx, llvm::DIExpression::get(ctx, std::nullopt)),
});
}];
let mlirBuilder = [{
let arguments = (ins Variadic<AnyType>:$operands);
let builders = [OpBuilder<(ins), [{
- build($_builder, $_state, llvm::None);
+ build($_builder, $_state, std::nullopt);
}]>];
let assemblyFormat = "attr-dict ($operands^ `:` type($operands))?";
let arguments = (ins Variadic<AnyType>:$operands);
let builders = [OpBuilder<(ins), [{
- build($_builder, $_state, llvm::None);
+ build($_builder, $_state, std::nullopt);
}]>];
let assemblyFormat = "attr-dict ($operands^ `:` type($operands))?";
let builders = [
OpBuilder<(ins CArg<"Optional<uint16_t>", "1">:$benefit,
- CArg<"Optional<StringRef>", "llvm::None">:$name)>,
+ CArg<"Optional<StringRef>", "std::nullopt">:$name)>,
];
let extraClassDeclaration = [{
//===------------------------------------------------------------------===//
let skipDefaultBuilders = 1;
let builders = [
OpBuilder<(ins "Value":$lowerBound, "Value":$upperBound, "Value":$step,
- CArg<"ValueRange", "llvm::None">:$iterArgs,
+ CArg<"ValueRange", "std::nullopt">:$iterArgs,
CArg<"function_ref<void(OpBuilder &, Location, Value, ValueRange)>",
"nullptr">)>
];
/// operand return llvm::None.
Optional<unsigned> getIterArgNumberForOpOperand(OpOperand &opOperand) {
if (opOperand.getOwner() != getOperation())
- return llvm::None;
+ return std::nullopt;
unsigned operandNumber = opOperand.getOperandNumber();
if (operandNumber < getNumControlOperands())
- return llvm::None;
+ return std::nullopt;
return operandNumber - getNumControlOperands();
}
"$overall = static_cast<" # scheme.returnType # ">("
"std::max(*$overall, $instance)); "
"} else { $overall = $instance; }}";
- let initializer = "::llvm::None";
+ let initializer = "::std::nullopt";
let instanceType = scheme.cppNamespace # "::" # scheme.enum.className;
let instance = scheme.cppNamespace # "::" # scheme.enum.className # "::" #
"$overall = static_cast<" # scheme.returnType # ">("
"std::min(*$overall, $instance)); "
"} else { $overall = $instance; }}";
- let initializer = "::llvm::None";
+ let initializer = "::std::nullopt";
let instanceType = scheme.cppNamespace # "::" # scheme.enum.className;
let instance = scheme.cppNamespace # "::" # scheme.enum.className # "::" #
let arguments = (ins Variadic<AnyType>:$operands);
let builders = [OpBuilder<(ins),
- [{ build($_builder, $_state, llvm::None); }]>
+ [{ build($_builder, $_state, std::nullopt); }]>
];
let assemblyFormat = "attr-dict ($operands^ `:` type($operands))?";
OpBuilder<(ins "Value":$source, "Value":$dest,
"ArrayRef<int64_t>":$innerDimsPos,
"ArrayRef<OpFoldResult>":$innerTiles,
- CArg<"Optional<Value>", "llvm::None">:$paddingValue,
+ CArg<"Optional<Value>", "std::nullopt">:$paddingValue,
CArg<"ArrayRef<int64_t>", "{}">:$outerDimsPerm)>
];
"Value":$source,
"ValueRange":$indices,
"AffineMap":$permutationMap,
- CArg<"Optional<ArrayRef<bool>>", "::llvm::None">:$inBounds)>,
+ CArg<"Optional<ArrayRef<bool>>", "::std::nullopt">:$inBounds)>,
/// 3. Builder that sets permutation map to 'getMinorIdentityMap'.
OpBuilder<(ins "VectorType":$vectorType,
"Value":$source,
"ValueRange":$indices,
"Value":$padding,
- CArg<"Optional<ArrayRef<bool>>", "::llvm::None">:$inBounds)>,
+ CArg<"Optional<ArrayRef<bool>>", "::std::nullopt">:$inBounds)>,
/// 4. Builder that sets padding to zero and permutation map to
/// 'getMinorIdentityMap'.
OpBuilder<(ins "VectorType":$vectorType,
"Value":$source,
"ValueRange":$indices,
- CArg<"Optional<ArrayRef<bool>>", "::llvm::None">:$inBounds)>,
+ CArg<"Optional<ArrayRef<bool>>", "::std::nullopt">:$inBounds)>,
];
let extraClassDeclaration = [{
"Value":$dest,
"ValueRange":$indices,
"AffineMap":$permutationMap,
- CArg<"Optional<ArrayRef<bool>>", "::llvm::None">:$inBounds)>,
+ CArg<"Optional<ArrayRef<bool>>", "::std::nullopt">:$inBounds)>,
/// 4. Builder with type inference that sets an empty mask and sets permutation
/// map to 'getMinorIdentityMap'.
OpBuilder<(ins "Value":$vector,
"Value":$dest,
"ValueRange":$indices,
- CArg<"Optional<ArrayRef<bool>>", "::llvm::None">:$inBounds)>,
+ CArg<"Optional<ArrayRef<bool>>", "::std::nullopt">:$inBounds)>,
];
let extraClassDeclaration = [{
/*defaultImplementation=*/[{
// Default implementation is only aimed for operations that implement the
// `getVectorType()` method.
- return $_op.getVectorType().cloneWith(/*shape=*/llvm::None,
+ return $_op.getVectorType().cloneWith(/*shape=*/std::nullopt,
IntegerType::get($_op.getContext(), /*width=*/1));
}]>,
];
DefaultValueCheckT<T, Optional<iterator_range<T>>> tryGetValues() const {
if (Optional<iterator<T>> beginIt = try_value_begin<T>())
return iterator_range<T>(getType(), *beginIt, value_end<T>());
- return llvm::None;
+ return std::nullopt;
}
template <typename T>
DefaultValueCheckT<T, Optional<iterator<T>>> try_value_begin() const;
Optional<DerivedAttrValueIteratorRange<T>> tryGetValues() const {
auto values = tryGetValues<Attribute>();
if (!values)
- return llvm::None;
+ return std::nullopt;
auto castFn = [](Attribute attr) { return attr.template cast<T>(); };
return DerivedAttrValueIteratorRange<T>(
Optional<DerivedAttrValueIterator<T>> try_value_begin() const {
if (auto values = tryGetValues<T>())
return values->begin();
- return llvm::None;
+ return std::nullopt;
}
}] # ElementsAttrInterfaceAccessors;
}
}];
let parameters = (ins ArrayRefParameter<"NamedAttribute", "">:$value);
let builders = [
- AttrBuilder<(ins CArg<"ArrayRef<NamedAttribute>", "llvm::None">:$value)>
+ AttrBuilder<(ins CArg<"ArrayRef<NamedAttribute>", "std::nullopt">:$value)>
];
let extraClassDeclaration = [{
using ValueType = ArrayRef<NamedAttribute>;
let builders = [OpBuilder<(ins CArg<"Optional<StringRef>", "{}">:$name)>];
let extraClassDeclaration = [{
/// Construct a module from the given location with an optional name.
- static ModuleOp create(Location loc, Optional<StringRef> name = llvm::None);
+ static ModuleOp create(Location loc, Optional<StringRef> name = std::nullopt);
/// Return the name of this module if present.
Optional<StringRef> getName() { return getSymName(); }
}
/// Return a clone of this type with the given new element type.
auto clone(::mlir::Type elementType) {
- return $_type.cloneWith(/*shape=*/llvm::None, elementType);
+ return $_type.cloneWith(/*shape=*/std::nullopt, elementType);
}
/// If an element type is an integer or a float, return its width. Otherwise,
using ShapedType::Trait<UnrankedMemRefType>::getDimSize;
using ShapedType::Trait<UnrankedMemRefType>::getDynamicDimIndex;
- ArrayRef<int64_t> getShape() const { return llvm::None; }
+ ArrayRef<int64_t> getShape() const { return std::nullopt; }
/// [deprecated] Returns the memory space in old raw integer representation.
/// New `Attribute getMemorySpace()` method should be used instead.
using ShapedType::Trait<UnrankedTensorType>::getDimSize;
using ShapedType::Trait<UnrankedTensorType>::getDynamicDimIndex;
- ArrayRef<int64_t> getShape() const { return llvm::None; }
+ ArrayRef<int64_t> getShape() const { return std::nullopt; }
}];
let skipDefaultBuilders = 1;
let genVerifyDecl = 1;
let storageType = attr.storageType;
let returnType = "::llvm::Optional<" # attr.returnType #">";
let convertFromStorage = "$_self ? " # returnType # "(" #
- attr.convertFromStorage # ") : (::llvm::None)";
+ attr.convertFromStorage # ") : (::std::nullopt)";
let valueType = attr.valueType;
let isOptional = 1;
opaqueOp->getSuccessor(i)))
return arg;
}
- return ::llvm::None;
+ return ::std::nullopt;
}]
>,
InterfaceMethod<[{
/*args=*/(ins),
/*methodBody=*/"",
/*defaultImplementation=*/[{
- return llvm::None;
+ return std::nullopt;
}]
>,
InterfaceMethod<[{
/*args=*/(ins),
/*methodBody=*/"",
/*defaultImplementation=*/[{
- return llvm::None;
+ return std::nullopt;
}]
>,
InterfaceMethod<[{
/*args=*/(ins),
/*methodBody=*/"",
/*defaultImplementation=*/[{
- return llvm::None;
+ return std::nullopt;
}]
>,
InterfaceMethod<[{
/*args=*/(ins),
/*methodBody=*/"",
/*defaultImplementation=*/[{
- return llvm::None;
+ return std::nullopt;
}]
>,
];
return isa<Effect>(it.getEffect()) && it.getValue() == value;
});
if (it == effects.end())
- return llvm::None;
+ return std::nullopt;
return *it;
}
auto vt = $_op.getResult().getType().
template dyn_cast<::mlir::VectorType>();
if (!vt)
- return ::mlir::None;
+ return ::std::nullopt;
::llvm::SmallVector<int64_t, 4> res(vt.getShape().begin(), vt.getShape().end());
return res;
}]
// DEF-NEXT: return ::mlir::success(!!value);
// DEF: .Default([&](llvm::StringRef keyword,
// DEF-NEXT: *mnemonic = keyword;
-// DEF-NEXT: return llvm::None;
+// DEF-NEXT: return std::nullopt;
def Test_Dialect: Dialect {
// DECL-NOT: TestDialect
// DEF-NEXT: ::mlir::impl::getAttrFromSortedRange((*this)->getAttrs().begin() + 1, (*this)->getAttrs().end() - 0, getCAttrAttrName()).dyn_cast_or_null<some-attr-kind>()
// DEF: ::llvm::Optional<some-return-type> AOp::getCAttr() {
// DEF-NEXT: auto attr = getCAttrAttr()
-// DEF-NEXT: return attr ? ::llvm::Optional<some-return-type>(attr.some-convert-from-storage()) : (::llvm::None);
+// DEF-NEXT: return attr ? ::llvm::Optional<some-return-type>(attr.some-convert-from-storage()) : (::std::nullopt);
// DEF: some-attr-kind AOp::getDAttrAttr()
// DEF-NEXT: ::mlir::impl::getAttrFromSortedRange((*this)->getAttrs().begin() + 1, (*this)->getAttrs().end() - 0, getDAttrAttrName()).dyn_cast_or_null<some-attr-kind>()
// DEF-NEXT: return ::mlir::impl::getAttrFromSortedRange({{.*}}).dyn_cast_or_null<some-attr-kind>()
// DEF: ::llvm::Optional<some-return-type> AgetOp::getCAttr() {
// DEF-NEXT: auto attr = getCAttrAttr()
-// DEF-NEXT: return attr ? ::llvm::Optional<some-return-type>(attr.some-convert-from-storage()) : (::llvm::None);
+// DEF-NEXT: return attr ? ::llvm::Optional<some-return-type>(attr.some-convert-from-storage()) : (::std::nullopt);
// Test setter methods
// ---
// DEF-NEXT: return ::mlir::success(!!value);
// DEF: .Default([&](llvm::StringRef keyword,
// DEF-NEXT: *mnemonic = keyword;
-// DEF-NEXT: return llvm::None;
+// DEF-NEXT: return std::nullopt;
def Test_Dialect: Dialect {
// DECL-NOT: TestDialect
(ins "ValueRange":$inputs, "ValueRange":$outputs,
CArg<"ArrayRef<NamedAttribute>", "{{}">:$attributes),
[{{
- buildStructuredOp($_builder, $_state, llvm::None, inputs, outputs,
+ buildStructuredOp($_builder, $_state, std::nullopt, inputs, outputs,
attributes, {0}::getRegionBuilder());
}]>,
OpBuilder<
}
parse.body() << " .Default([&](llvm::StringRef keyword, llvm::SMLoc) {\n"
" *mnemonic = keyword;\n"
- " return llvm::None;\n"
+ " return std::nullopt;\n"
" });";
printer.body() << " .Default([](auto) { return ::mlir::failure(); });";
os << formatv(" .Case(\"{1}\", {0}::{2})\n", enumName, str,
makeIdentifier(symbol));
}
- os << " .Default(::llvm::None);\n";
+ os << " .Default(::std::nullopt);\n";
os << "}\n";
}
if (auto val = enumerant.getValue())
os.indent(6) << formatv(".Case(\"{0}\", {1})\n", enumerant.getStr(), val);
}
- os.indent(6) << ".Default(::llvm::None);\n";
+ os.indent(6) << ".Default(::std::nullopt);\n";
- os << " if (bit) { val |= *bit; } else { return ::llvm::None; }\n";
+ os << " if (bit) { val |= *bit; } else { return ::std::nullopt; }\n";
os << " }\n";
os << formatv(" return static_cast<{0}>(val);\n", enumName);
os << formatv(" case {0}: return {1}::{2};\n", value, enumName,
makeIdentifier(symbol));
}
- os << " default: return ::llvm::None;\n"
+ os << " default: return ::std::nullopt;\n"
<< " }\n"
<< "}\n\n";
}
makeIdentifier(allBitsUnsetCase->getSymbol()));
}
int64_t validBits = enumDef.getValueAsInt("validBits");
- os << formatv(" if (value & ~static_cast<{0}>({1}u)) return llvm::None;\n",
+ os << formatv(" if (value & ~static_cast<{0}>({1}u)) return std::nullopt;\n",
underlyingType, validBits);
os << formatv(" return static_cast<{0}>(value);\n", enumName);
os << "}\n";
if (classCasePair.getValue().size() < enumAttr.getAllCases().size())
os << " default: break;\n";
os << " }\n"
- << " return llvm::None;\n"
+ << " return std::nullopt;\n"
<< "}\n";
}
}
}
os << " default: break;\n";
os << " }\n"
- << " return llvm::None;\n"
+ << " return std::nullopt;\n"
<< "}\n";
}
}
projects / platform / upstream / llvm.git / commitdiff