Replace trio of XxxxLiteral types with a single Literal type.
Throughout SkSL we've begun using doubles as a convenient way to store
any SkSL value (int, float, bool) in a single type. This idea has now
been extended to literals. Rather than having three expression kinds for
integers, floats and boolean literals, we can have just one. These can
be accessed in a type-specific way (`floatValue`, `intValue`, and
`boolValue` return the expected type, or assert if it's not the
matching type), or in a type-agnostic way (`value` will return a double
and works on any type of Literal).
This allows us to remove a complex template trick (Literal<T> is gone),
removes two redundant Expression types, and and lets us reduce our code
size in ConstantFolder, FunctionCall, etc.
Most of the conversion process was pretty straightforward:
* `IntLiteral::Make` becomes `Literal::MakeInt`
* `x.is<IntLiteral>()` becomes `x.isIntLiteral()`
* `x.as<IntLiteral>.value()` becomes `x.as<Literal>.intValue()`
Change-Id: Ic328533611e4551669c7fc9d7f9c03e34699f3f6
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/447836
Commit-Queue: John Stiles <johnstiles@google.com>
Auto-Submit: John Stiles <johnstiles@google.com>
Reviewed-by: Brian Osman <brianosman@google.com>
diff --git a/src/sksl/codegen/SkSLMetalCodeGenerator.cpp b/src/sksl/codegen/SkSLMetalCodeGenerator.cpp
index 02e8b14..7f0e5e7 100644
--- a/src/sksl/codegen/SkSLMetalCodeGenerator.cpp
+++ b/src/sksl/codegen/SkSLMetalCodeGenerator.cpp
@@ -124,9 +124,6 @@
case Expression::Kind::kBinary:
this->writeBinaryExpression(expr.as<BinaryExpression>(), parentPrecedence);
break;
- case Expression::Kind::kBoolLiteral:
- this->writeBoolLiteral(expr.as<BoolLiteral>());
- break;
case Expression::Kind::kConstructorArray:
case Expression::Kind::kConstructorStruct:
this->writeAnyConstructor(expr.asAnyConstructor(), "{", "}", parentPrecedence);
@@ -149,14 +146,11 @@
case Expression::Kind::kConstructorCompoundCast:
this->writeCastConstructor(expr.asAnyConstructor(), "(", ")", parentPrecedence);
break;
- case Expression::Kind::kIntLiteral:
- this->writeIntLiteral(expr.as<IntLiteral>());
- break;
case Expression::Kind::kFieldAccess:
this->writeFieldAccess(expr.as<FieldAccess>());
break;
- case Expression::Kind::kFloatLiteral:
- this->writeFloatLiteral(expr.as<FloatLiteral>());
+ case Expression::Kind::kLiteral:
+ this->writeLiteral(expr.as<Literal>());
break;
case Expression::Kind::kFunctionCall:
this->writeFunctionCall(expr.as<FunctionCall>());
@@ -1673,23 +1667,24 @@
}
}
-void MetalCodeGenerator::writeBoolLiteral(const BoolLiteral& b) {
- this->write(b.value() ? "true" : "false");
-}
-
-void MetalCodeGenerator::writeIntLiteral(const IntLiteral& i) {
- const Type& type = i.type();
- if (type == *fContext.fTypes.fUInt) {
- this->write(to_string(i.value() & 0xffffffff) + "u");
- } else if (type == *fContext.fTypes.fUShort) {
- this->write(to_string(i.value() & 0xffff) + "u");
- } else {
- this->write(to_string(i.value()));
+void MetalCodeGenerator::writeLiteral(const Literal& l) {
+ const Type& type = l.type();
+ if (type.isFloat()) {
+ this->write(to_string(l.floatValue()));
+ return;
}
-}
-
-void MetalCodeGenerator::writeFloatLiteral(const FloatLiteral& f) {
- this->write(to_string(f.value()));
+ if (type.isInteger()) {
+ if (type == *fContext.fTypes.fUInt) {
+ this->write(to_string(l.intValue() & 0xffffffff) + "u");
+ } else if (type == *fContext.fTypes.fUShort) {
+ this->write(to_string(l.intValue() & 0xffff) + "u");
+ } else {
+ this->write(to_string(l.intValue()));
+ }
+ return;
+ }
+ SkASSERT(type.isBoolean());
+ this->write(l.boolValue() ? "true" : "false");
}
void MetalCodeGenerator::writeSetting(const Setting& s) {