use crate::ast::Program;
pub const THROWABLES: &[(&str, &str)] = &[
("Throwable", ""),
("Error", "Throwable"),
("Exception", "Throwable"),
("RuntimeException", "Exception"),
("IllegalArgumentException", "RuntimeException"),
("NumberFormatException", "IllegalArgumentException"),
("IllegalStateException", "RuntimeException"),
("ArithmeticException", "RuntimeException"),
("NullPointerException", "RuntimeException"),
("ClassCastException", "RuntimeException"),
("UnsupportedOperationException", "RuntimeException"),
("NegativeArraySizeException", "RuntimeException"),
("IndexOutOfBoundsException", "RuntimeException"),
(
"ArrayIndexOutOfBoundsException",
"IndexOutOfBoundsException",
),
(
"StringIndexOutOfBoundsException",
"IndexOutOfBoundsException",
),
("PatternSyntaxException", "IllegalArgumentException"),
("ConcurrentModificationException", "RuntimeException"),
("NoSuchElementException", "RuntimeException"),
("EmptyStackException", "RuntimeException"),
("InputMismatchException", "NoSuchElementException"),
("IOException", "Exception"),
("ArrayStoreException", "RuntimeException"),
("AssertionError", "Error"),
("LinkageError", "Error"),
("ExceptionInInitializerError", "LinkageError"),
("NoClassDefFoundError", "LinkageError"),
("CloneNotSupportedException", "Exception"),
("IllegalFormatException", "IllegalArgumentException"),
("IllegalFormatConversionException", "IllegalFormatException"),
("IllegalFormatWidthException", "IllegalFormatException"),
("IllegalFormatPrecisionException", "IllegalFormatException"),
("MissingFormatArgumentException", "IllegalFormatException"),
("UnknownFormatConversionException", "IllegalFormatException"),
(
"FormatFlagsConversionMismatchException",
"IllegalFormatException",
),
("IllegalFormatFlagsException", "IllegalFormatException"),
("MissingFormatWidthException", "IllegalFormatException"),
("IllegalFormatCodePointException", "IllegalFormatException"),
];
const CAUSE_CTORS: &[&str] = &[
"Error",
"Exception",
"RuntimeException",
"IllegalArgumentException",
"IllegalStateException",
"UnsupportedOperationException",
"ConcurrentModificationException",
"NoSuchElementException",
"IOException",
];
pub fn is_throwable(name: &str) -> bool {
THROWABLES.iter().any(|(n, _)| *n == name)
}
pub fn qualified_throwable(name: &str) -> Option<String> {
if !is_throwable(name) {
return None;
}
Some(match name {
"PatternSyntaxException" => format!("java.util.regex.{name}"),
"IOException" => format!("java.io.{name}"),
"ConcurrentModificationException"
| "NoSuchElementException"
| "EmptyStackException"
| "InputMismatchException"
| "IllegalFormatException"
| "IllegalFormatConversionException"
| "IllegalFormatWidthException"
| "IllegalFormatPrecisionException"
| "MissingFormatArgumentException"
| "UnknownFormatConversionException"
| "FormatFlagsConversionMismatchException"
| "IllegalFormatFlagsException"
| "MissingFormatWidthException"
| "IllegalFormatCodePointException" => format!("java.util.{name}"),
_ => format!("java.lang.{name}"),
})
}
pub fn qualified_class(name: &str) -> Option<String> {
if matches!(name, "Object" | "StringBuilder" | "StringBuffer") {
return Some(format!("java.lang.{name}"));
}
qualified_throwable(name)
}
pub fn qualified_functional(name: &str) -> Option<String> {
if !FUNCTIONAL.iter().any(|(n, _, _)| *n == name) {
return None;
}
Some(match name {
"Runnable" => format!("java.lang.{name}"),
"Callable" => format!("java.util.concurrent.{name}"),
"Comparator" => format!("java.util.{name}"),
_ => format!("java.util.function.{name}"),
})
}
pub const FUNCTIONAL: &[(&str, &str, &str)] = &[
("Runnable", "void run()", ""),
("Callable", "Object call()", ""),
("Supplier", "Object get()", ""),
(
"Consumer",
"void accept(Object t)",
"default Consumer andThen(Consumer after) { return t -> { this.accept(t); after.accept(t); }; }",
),
(
"BiConsumer",
"void accept(Object t, Object u)",
"default BiConsumer andThen(BiConsumer after) { return (t, u) -> { this.accept(t, u); after.accept(t, u); }; } \
static Function mapMulti$(BiConsumer mapper) { return t -> { ArrayList buf = new ArrayList(); mapper.accept(t, buf::add); return buf; }; }",
),
(
"Function",
"Object apply(Object t)",
"default Function andThen(Function after) { return t -> after.apply(this.apply(t)); } \
default Function compose(Function before) { return v -> this.apply(before.apply(v)); } \
static Function identity() { return t -> t; }",
),
(
"BiFunction",
"Object apply(Object t, Object u)",
"default BiFunction andThen(Function after) { return (t, u) -> after.apply(this.apply(t, u)); }",
),
(
"UnaryOperator",
"Object apply(Object t)",
"default Function andThen(Function after) { return t -> after.apply(this.apply(t)); } \
default Function compose(Function before) { return v -> this.apply(before.apply(v)); } \
static UnaryOperator identity() { return t -> t; }",
),
(
"BinaryOperator",
"Object apply(Object t, Object u)",
"default BiFunction andThen(Function after) { return (t, u) -> after.apply(this.apply(t, u)); } \
static BinaryOperator minBy(Comparator comparator) { return (a, b) -> comparator.compare(a, b) <= 0 ? a : b; } \
static BinaryOperator maxBy(Comparator comparator) { return (a, b) -> comparator.compare(a, b) >= 0 ? a : b; }",
),
(
"Predicate",
"boolean test(Object t)",
"default Predicate and(Predicate other) { return t -> this.test(t) && other.test(t); } \
default Predicate negate() { return t -> !this.test(t); } \
default Predicate or(Predicate other) { return t -> this.test(t) || other.test(t); } \
static Predicate not(Predicate target) { return target.negate(); } \
static Predicate isEqual(Object targetRef) { return t -> targetRef == null ? t == null : targetRef.equals(t); }",
),
(
"BiPredicate",
"boolean test(Object t, Object u)",
"default BiPredicate and(BiPredicate other) { return (t, u) -> this.test(t, u) && other.test(t, u); } \
default BiPredicate negate() { return (t, u) -> !this.test(t, u); } \
default BiPredicate or(BiPredicate other) { return (t, u) -> this.test(t, u) || other.test(t, u); }",
),
(
"Comparator",
"int compare(Object a, Object b)",
"default Comparator reversed() { return (a, b) -> this.compare(b, a); } \
default Comparator thenComparing(Object other) { Comparator c = Comparator.asComparator(other); return (a, b) -> { int r = this.compare(a, b); if (r != 0) { return r; } return c.compare(a, b); }; } \
default Comparator thenComparing(Function key, Comparator keyCmp) { return this.thenComparing(Comparator.comparing(key, keyCmp)); } \
default Comparator thenComparingInt(Function key) { return this.thenComparing(key); } \
default Comparator thenComparingLong(Function key) { return this.thenComparing(key); } \
default Comparator thenComparingDouble(Function key) { return this.thenComparing(key); } \
static Comparator asComparator(Object x) { if (Comparator.isKeyExtractor(x)) { Function k = (Function) x; return (a, b) -> k.apply(a).compareTo(k.apply(b)); } return (Comparator) x; } \
static Comparator naturalOrder() { return (a, b) -> a.compareTo(b); } \
static Comparator reverseOrder() { return (a, b) -> b.compareTo(a); } \
static Comparator comparing(Function key) { return (a, b) -> key.apply(a).compareTo(key.apply(b)); } \
static Comparator comparing(Function key, Comparator keyCmp) { return (a, b) -> keyCmp.compare(key.apply(a), key.apply(b)); } \
static Comparator nullsFirst(Comparator c) { return (a, b) -> { if (a == null) { return b == null ? 0 : -1; } if (b == null) { return 1; } return c == null ? 0 : c.compare(a, b); }; } \
static Comparator nullsLast(Comparator c) { return (a, b) -> { if (a == null) { return b == null ? 0 : 1; } if (b == null) { return -1; } return c == null ? 0 : c.compare(a, b); }; } \
static Comparator comparingInt(Function key) { return Comparator.comparing(key); } \
static Comparator comparingLong(Function key) { return Comparator.comparing(key); } \
static Comparator comparingDouble(Function key) { return Comparator.comparing(key); } \
static Comparator comparingByKey() { return (a, b) -> a.getKey().compareTo(b.getKey()); } \
static Comparator comparingByKey(Comparator c) { return (a, b) -> c.compare(a.getKey(), b.getKey()); } \
static Comparator comparingByValue() { return (a, b) -> a.getValue().compareTo(b.getValue()); } \
static Comparator comparingByValue(Comparator c) { return (a, b) -> c.compare(a.getValue(), b.getValue()); }",
),
("IntSupplier", "int getAsInt()", ""),
(
"IntPredicate",
"boolean test(int value)",
"default IntPredicate and(IntPredicate other) { return value -> this.test(value) && other.test(value); } \
default IntPredicate negate() { return value -> !this.test(value); } \
default IntPredicate or(IntPredicate other) { return value -> this.test(value) || other.test(value); }",
),
(
"IntConsumer",
"void accept(int value)",
"default IntConsumer andThen(IntConsumer after) { return value -> { this.accept(value); after.accept(value); }; }",
),
(
"IntUnaryOperator",
"int applyAsInt(int operand)",
"default IntUnaryOperator compose(IntUnaryOperator before) { return v -> this.applyAsInt(before.applyAsInt(v)); } \
default IntUnaryOperator andThen(IntUnaryOperator after) { return v -> after.applyAsInt(this.applyAsInt(v)); } \
static IntUnaryOperator identity() { return v -> v; }",
),
("IntBinaryOperator", "int applyAsInt(int left, int right)", ""),
("ToIntFunction", "int applyAsInt(Object value)", ""),
("ToDoubleFunction", "double applyAsDouble(Object value)", ""),
("ToLongFunction", "long applyAsLong(Object value)", ""),
("IntFunction", "Object apply(int value)", ""),
("LongFunction", "Object apply(long value)", ""),
("DoubleFunction", "Object apply(double value)", ""),
("IntToLongFunction", "long applyAsLong(int value)", ""),
("IntToDoubleFunction", "double applyAsDouble(int value)", ""),
("LongToIntFunction", "int applyAsInt(long value)", ""),
("DoubleToIntFunction", "int applyAsInt(double value)", ""),
("LongSupplier", "long getAsLong()", ""),
("DoubleSupplier", "double getAsDouble()", ""),
(
"LongUnaryOperator",
"long applyAsLong(long operand)",
"static LongUnaryOperator identity() { return v -> v; }",
),
("LongBinaryOperator", "long applyAsLong(long left, long right)", ""),
(
"DoubleUnaryOperator",
"double applyAsDouble(double operand)",
"static DoubleUnaryOperator identity() { return v -> v; }",
),
(
"DoubleBinaryOperator",
"double applyAsDouble(double left, double right)",
"",
),
(
"LongPredicate",
"boolean test(long value)",
"default LongPredicate negate() { return value -> !this.test(value); }",
),
(
"DoublePredicate",
"boolean test(double value)",
"default DoublePredicate negate() { return value -> !this.test(value); }",
),
("LongConsumer", "void accept(long value)", ""),
("DoubleConsumer", "void accept(double value)", ""),
];
pub fn is_functional(name: &str) -> bool {
FUNCTIONAL.iter().any(|(n, _, _)| *n == name)
}
fn prelude_source(declared: &[String]) -> String {
let mut src =
String::from("public class __JavaLang { public static void main(String[] a) { } }\n");
for (name, sup) in THROWABLES {
if declared.iter().any(|d| d == name) {
continue;
}
let extends = if sup.is_empty() {
String::new()
} else {
format!(" extends {sup}")
};
src.push_str(&format!("class {name}{extends} {{\n"));
if sup.is_empty() {
src.push_str(" String detailMessage;\n");
src.push_str(" Throwable cause;\n boolean causeSet;\n");
src.push_str(" ArrayList suppressed;\n");
src.push_str(&format!(" {name}() {{ }}\n"));
src.push_str(&format!(" {name}(String m) {{ detailMessage = m; }}\n"));
src.push_str(&format!(
" {name}(String m, Throwable c) {{ detailMessage = m; cause = c; causeSet = true; }}\n"
));
src.push_str(&format!(
" {name}(Throwable c) {{ detailMessage = (c == null ? null : c.toString()); \
cause = c; causeSet = true; }}\n"
));
src.push_str(" Throwable getCause() { return cause; }\n");
if !declared
.iter()
.any(|d| d == "IllegalStateException" || d == "IllegalArgumentException")
{
src.push_str(
" Throwable initCause(Throwable c) { \
if (causeSet) { throw new IllegalStateException(\"Can't overwrite cause with \" \
+ (c == null ? \"a null\" : c.toString()), this); } \
if (c == this) { throw new IllegalArgumentException(\"Self-causation not permitted\", this); } \
cause = c; causeSet = true; return this; }\n",
);
}
let refusals = if declared
.iter()
.any(|d| d == "IllegalArgumentException" || d == "NullPointerException")
{
""
} else {
"if (e == this) { throw new IllegalArgumentException(\"Self-suppression not permitted\", e); } \
if (e == null) { throw new NullPointerException(\"Cannot suppress a null exception.\"); } "
};
src.push_str(&format!(
" void addSuppressed(Throwable e) {{ {refusals}\
if (suppressed == null) {{ suppressed = new ArrayList<>(); }} \
suppressed.add(e); }}\n"
));
src.push_str(
" Throwable[] getSuppressed() { int n = suppressed == null ? 0 : suppressed.size(); \
Throwable[] out = new Throwable[n]; \
for (int i = 0; i < n; i++) { out[i] = (Throwable) suppressed.get(i); } \
return out; }\n",
);
src.push_str(" String getMessage() { return detailMessage; }\n");
src.push_str(" String getLocalizedMessage() { return getMessage(); }\n");
src.push_str(
" void printStackTrace() { System.err.println(this); \
Throwable[] s = getSuppressed(); \
for (int i = 0; i < s.length; i++) { System.err.println(\"\\tSuppressed: \" + s[i]); } \
Throwable c = getCause(); \
while (c != null && c != this) { System.err.println(\"Caused by: \" + c); \
c = c.getCause(); } }\n",
);
src.push_str(
" String toString() { String n = this.getClass().getName(); \
String m = getLocalizedMessage(); \
if (m == null) { return n; } return n + \": \" + m; }\n",
);
} else if *name == "ExceptionInInitializerError" {
src.push_str(
" ExceptionInInitializerError() { cause = null; causeSet = true; }\n \
ExceptionInInitializerError(String m) { detailMessage = m; cause = null; causeSet = true; }\n \
ExceptionInInitializerError(Throwable thrown) { cause = thrown; causeSet = true; }\n \
Throwable getException() { return getCause(); }\n",
);
} else if *name == "PatternSyntaxException" {
src.push_str(
" String desc;\n String pattern;\n int index;\n boolean refused;\n \
PatternSyntaxException(String desc, String regex, int index) { \
super(desc); this.desc = desc; this.pattern = regex; this.index = index; }\n \
String getDescription() { return desc; }\n \
int getIndex() { return index; }\n \
String getPattern() { return pattern; }\n \
String getMessage() { if (refused) { return detailMessage; } \
StringBuilder sb = new StringBuilder(); sb.append(desc); \
if (index >= 0) { sb.append(\" near index \"); sb.append(index); } \
sb.append(\"\n\"); sb.append(pattern); \
if (index >= 0 && pattern != null && index < pattern.length()) { sb.append(\"\n\"); \
for (int i = 0; i < index; i++) { sb.append(pattern.charAt(i) == '\t' ? '\t' : ' '); } \
sb.append('^'); } return sb.toString(); }\n",
);
} else {
src.push_str(&format!(" {name}() {{ }}\n"));
src.push_str(&format!(" {name}(String m) {{ super(m); }}\n"));
if CAUSE_CTORS.contains(name) {
src.push_str(&format!(
" {name}(String m, Throwable c) {{ super(m, c); }}\n {name}(Throwable c) {{ super(c); }}\n"
));
}
}
src.push_str("}\n");
}
src
}
pub fn inject(prog: &mut Program) -> Result<(), String> {
if prog.uses_exceptions {
let src = prelude_source(&declared_names(prog));
merge(prog, &src)?;
}
if prog.uses_functional {
let src = functional_source(&declared_names(prog));
merge(prog, &src)?;
}
Ok(())
}
fn declared_names(prog: &Program) -> Vec<String> {
prog.classes.iter().map(|c| c.name.clone()).collect()
}
fn merge(prog: &mut Program, src: &str) -> Result<(), String> {
let parsed = crate::parser::parse(src)?;
prog.classes.extend(
parsed
.classes
.into_iter()
.filter(|c| !c.name.starts_with("__")),
);
prog.methods.extend(
parsed
.methods
.into_iter()
.filter(|m| !m.owner.starts_with("__")),
);
Ok(())
}
fn functional_source(declared: &[String]) -> String {
let mut src = String::from(
"public class __JavaUtilFunction { public static void main(String[] a) { } }\n",
);
for (name, sam, members) in FUNCTIONAL {
if declared.iter().any(|d| d == name) {
continue;
}
src.push_str(&format!("interface {name} {{ {sam}; {members} }}\n"));
}
src
}