LDEV-6303 ExpressionDefault wrapper and duplicate re-fire

Author: zspitzer

core/src/main/java/lucee/runtime/ComponentImpl.java

@@ -115,6 +115,9 @@
 import lucee.runtime.type.scope.ArgumentImpl;
 import lucee.runtime.type.scope.ArgumentIntKey;
 import lucee.runtime.type.scope.Variables;
+
+import java.lang.reflect.Method;
+import java.util.concurrent.ConcurrentHashMap;
 import lucee.runtime.type.util.ArrayUtil;
 import lucee.runtime.type.util.ComponentUtil;
 import lucee.runtime.type.util.KeyConstants;
@@ -367,6 +370,8 @@ public ComponentImpl _duplicate(boolean deepCopy, boolean isTop) {
 				if (useShadow) {
 					addUDFS(trg, ((ComponentScopeShadow) scope).getShadow(), ((ComponentScopeShadow) trg.scope).getShadow());
 				}
+
+				reFireExpressionDefaults(trg);
 			}
 		}
 		finally {
@@ -376,6 +381,69 @@ public ComponentImpl _duplicate(boolean deepCopy, boolean isTop) {
 		return trg;
 	}
 
+	// SEED_METHOD_NONE flags "Page class compiled by pre-LDEV-6303 Lucee" (cross-version compat).
+	private static final java.util.Map<Class<?>, Method> SEED_METHOD_CACHE = new ConcurrentHashMap<Class<?>, Method>();
+	private static final Method SEED_METHOD_NONE;
+	static {
+		Method tmp = null;
+		try {
+			tmp = Object.class.getDeclaredMethod("hashCode");
+		}
+		catch (NoSuchMethodException e) {}
+		SEED_METHOD_NONE = tmp;
+	}
+
+	private static Method lookupSeedMethod(Class<?> pageClass) {
+		Method m = SEED_METHOD_CACHE.get(pageClass);
+		if (m != null) return m == SEED_METHOD_NONE ? null : m;
+		try {
+			m = pageClass.getDeclaredMethod("_seedExpressionDefaults", PageContext.class);
+			SEED_METHOD_CACHE.put(pageClass, m);
+			return m;
+		}
+		catch (NoSuchMethodException e) {
+			SEED_METHOD_CACHE.put(pageClass, SEED_METHOD_NONE);
+			return null;
+		}
+	}
+
+	private static void reFireExpressionDefaults(ComponentImpl trg) {
+		PageContext pc = ThreadLocalPageContext.get();
+		if (pc == null) return;
+
+		Variables prevVars = pc.variablesScope();
+		try {
+			if (trg.scope instanceof Variables) pc.setVariablesScope((Variables) trg.scope);
+
+			ComponentImpl walker = trg;
+			while (walker != null) {
+				if (walker.pageSource != null) {
+					try {
+						lucee.runtime.Page page = walker.pageSource.loadPage(pc, false);
+						if (page != null) {
+							Method seed = lookupSeedMethod(page.getClass());
+							if (seed != null) {
+								try {
+									seed.invoke(null, pc);
+								}
+								catch (Throwable t) {
+									ExceptionUtil.rethrowIfNecessary(t);
+								}
+							}
+						}
+					}
+					catch (PageException pe) {
+						break;
+					}
+				}
+				walker = (ComponentImpl) walker.base;
+			}
+		}
+		finally {
+			if (prevVars != null) pc.setVariablesScope(prevVars);
+		}
+	}
+
 	private static void addUDFS(ComponentImpl trgComp, Map src, Map trg) {
 		if (!src.isEmpty()) {
 			Iterator it = src.entrySet().iterator();

core/src/main/java/lucee/runtime/component/ExpressionDefault.java

@@ -0,0 +1,32 @@
+package lucee.runtime.component;
+
+/** Immutable source-string wrapper for non-foldable cfproperty expression-form defaults. */
+public final class ExpressionDefault {
+
+	private final String source;
+
+	public ExpressionDefault(String source) {
+		this.source = source == null ? "" : source;
+	}
+
+	public String getSource() {
+		return source;
+	}
+
+	@Override
+	public String toString() {
+		return source;
+	}
+
+	@Override
+	public boolean equals(Object obj) {
+		if (this == obj) return true;
+		if (!(obj instanceof ExpressionDefault)) return false;
+		return source.equals(((ExpressionDefault) obj).source);
+	}
+
+	@Override
+	public int hashCode() {
+		return source.hashCode();
+	}
+}

core/src/main/java/lucee/runtime/component/PropertyImpl.java

@@ -81,6 +81,8 @@ protected final int hash() {
 	@Override
 	public String getDefault() {
 		if (_default == null) return null;
+		// expression-form: source string would corrupt callers piping it into scope.set
+		if (_default instanceof ExpressionDefault) return null;
 		try {
 			return Caster.toString(_default);
 		}

core/src/main/java/lucee/transformer/bytecode/PageImpl.java

@@ -765,6 +765,8 @@ else if (functions.length <= 10) {
 		// newInstance/initComponent/call
 		writeOutStatic(optionalPS, constr, keys, cw, comp, className);
 
+		writeOutSeedExpressionDefaults(optionalPS, constr, keys, cw, comp, className);
+
 		// set field subs
 		FieldVisitor fv = cw.visitField(Opcodes.ACC_PRIVATE, "subs", "[Llucee/runtime/CIPage;", null, null);
 		fv.visitEnd();
@@ -1229,10 +1231,9 @@ private void writeOutStatic(PageSource optionalPS, ConstrBytecodeContext constr,
 								// prop.setDefault(value) if it's a simple literal
 								// Only handle simple literals (Literal interface) - complex expressions like now()
 								// or #myVar# need PageContext and must be evaluated at runtime, not class-load time
-								if (propDefaultAttr != null && propDefaultAttr.getValue() instanceof Literal) {
+								if (propDefaultAttr != null && propDefaultAttr.getValue() != null) {
 									Expression defaultExpr = propDefaultAttr.getValue();
 
-									// Handle simple literals only - complex expressions handled at runtime
 									if (defaultExpr instanceof LitStringImpl) {
 										String value = ((LitStringImpl) defaultExpr).getString();
 										ga.loadLocal(propLocal);
@@ -1253,7 +1254,31 @@ else if (defaultExpr instanceof LitBooleanImpl) {
 										ga.box(Type.BOOLEAN_TYPE);
 										ga.invokeVirtual(Types.PROPERTY_IMPL, new Method("setDefault", Type.VOID_TYPE, new Type[] { Types.OBJECT }));
 									}
-									// else: complex expression - will be handled at runtime in TagProperty
+									else {
+										String source;
+										try {
+											int start = defaultExpr.getStart().pos;
+											int end = defaultExpr.getEnd().pos;
+											// json() consumes opening { or [ before recording position; back up
+											if (start > 0) {
+												String peek = sourceCode.subCFMLString(start - 1, 1).toString();
+												if (peek.length() == 1 && (peek.charAt(0) == '{' || peek.charAt(0) == '[')) {
+													start--;
+												}
+											}
+											source = sourceCode.subCFMLString(start, end - start).toString();
+										}
+										catch (Exception e) {
+											source = "";
+										}
+										Type EXPRESSION_DEFAULT = Type.getType("Llucee/runtime/component/ExpressionDefault;");
+										ga.loadLocal(propLocal);
+										ga.newInstance(EXPRESSION_DEFAULT);
+										ga.dup();
+										ga.push(source);
+										ga.invokeConstructor(EXPRESSION_DEFAULT, new Method("<init>", Type.VOID_TYPE, new Type[] { Types.STRING }));
+										ga.invokeVirtual(Types.PROPERTY_IMPL, new Method("setDefault", Type.VOID_TYPE, new Type[] { Types.OBJECT }));
+									}
 								}
 
 								// Collect dynamic attributes (non-standard attributes)
@@ -1540,6 +1565,59 @@ else if (defaultExpr instanceof LitBooleanImpl) {
 
 	}
 
+	private void writeOutSeedExpressionDefaults(PageSource optionalPS, ConstrBytecodeContext constr, Map<LitString, Integer> keys, ClassWriter cw, TagCIObject component,
+			String name) throws TransformerException {
+		if (component == null || component.getBody() == null) return;
+		List<Statement> statements = component.getBody().getStatements();
+		if (statements == null) return;
+
+		List<TagProperty> exprDefProps = new ArrayList<TagProperty>();
+		for (Statement stmt: statements) {
+			if (!(stmt instanceof TagProperty)) continue;
+			TagProperty tagProp = (TagProperty) stmt;
+			Attribute defaultAttr = tagProp.getAttribute("default");
+			if (defaultAttr == null || defaultAttr.getValue() == null) continue;
+			Expression defaultExpr = defaultAttr.getValue();
+			if (defaultExpr instanceof LitStringImpl || defaultExpr instanceof LitNumberImpl || defaultExpr instanceof LitBooleanImpl) continue;
+			Attribute nameAttr = tagProp.getAttribute("name");
+			if (nameAttr == null || nameAttr.getValue() == null) continue;
+			exprDefProps.add(tagProp);
+		}
+
+		// Method shell always emitted on component classes — empty body is JIT no-op; ensures
+		// presence-of-method is stable for ComponentImpl._duplicate's reflection lookup.
+		Method seedMethod = new Method("_seedExpressionDefaults", Types.VOID, new Type[] { Types.PAGE_CONTEXT });
+		GeneratorAdapter ga = new GeneratorAdapter(Opcodes.ACC_PUBLIC + Opcodes.ACC_STATIC, seedMethod, null, new Type[] { Types.THROWABLE }, cw);
+		BytecodeContext bc = new BytecodeContext(config, optionalPS, constr, this, keys, cw, name, ga, seedMethod, writeLog(), suppressWSbeforeArg, output, returnValue,
+				sourceCode.getSourceOffset());
+
+		Method METHOD_VARIABLES_SCOPE = new Method("variablesScope", Types.VARIABLES, new Type[] {});
+		Method METHOD_SET_EL = new Method("setEL", Types.OBJECT, new Type[] { Types.COLLECTION_KEY, Types.OBJECT });
+
+		for (TagProperty tagProp: exprDefProps) {
+			Attribute nameAttr = tagProp.getAttribute("name");
+			Attribute defaultAttr = tagProp.getAttribute("default");
+			String propName = nameAttr.getValue() instanceof Literal ? ((Literal) nameAttr.getValue()).getString() : null;
+			if (propName == null) continue;
+			Expression defaultExpr = defaultAttr.getValue();
+
+			defaultExpr.writeOut(bc, Expression.MODE_REF);
+			int defaultLocal = ga.newLocal(Types.OBJECT);
+			ga.storeLocal(defaultLocal);
+
+			ga.loadArg(0);
+			ga.invokeVirtual(Types.PAGE_CONTEXT, METHOD_VARIABLES_SCOPE);
+			ga.push(propName);
+			ga.invokeStatic(KEY_IMPL, KEY_INIT);
+			ga.loadLocal(defaultLocal);
+			ga.invokeInterface(Types.SCOPE, METHOD_SET_EL);
+			ga.pop();
+		}
+
+		ga.returnValue();
+		ga.endMethod();
+	}
+
 	private String getTagAttributeValue(Tag tag, String attrName) {
 		Attribute attr = tag.getAttribute(attrName);
 		if (attr != null && attr.getValue() != null) {