fix lvalue poof when calling method on rvalues

build/ultratiny.flx

@@ -58,31 +58,57 @@ class Z: Y
 class A
 {
 	init() { }
-	virtual fn foo(a: Y) -> Y
+	virtual fn lol(a: Y) -> &Y
 	{
-		return Y(c: 471)
+		std::io::println("A::foo()")
+		return alloc Y(c: 471)
 	}
 }
 
 class B : A
 {
 	init() : super() { }
 
-	override fn foo(a: Y) -> Y
+	override fn foo(a: Y) -> &Y
 	{
-		return Y(c: 748)
+		std::io::println("B::foo()")
+		return alloc Z(c: 748)
+		// return 3
 	}
 }
 
+// import std::io as _
+
+// @entry fn main()
+// {
+// 	println("hello, world!")
+// }
+
+// issue #0: we basically don't really even check for overriding methods properly.
 // issue #1: co/contra-variance of return and parameter types for virtual methods
 // issue #2: crashes when initialisers have default arguments??
 
 // classes are a Bad Idea (tm) ):
 
+struct Tmp
+{
+	k: int
+	m: int
+
+	fn meth() -> int => k * m
+}
+
 @entry fn main()
 {
-	let a = B()
-	let q = a.foo(Y(c: 1)).data
+	// let a = B()
+	// let q = a.foo(Y(c: 1)).data
+
+	// let y: &X = alloc Y(c: 41)
+	// std::io::println("y = %", y.data)
+
+	// let q = Tmp(k: 3, m: 7).meth()
+
+	// let q = B().foo(Y(c: 1)).data
 	std::io::println("thing: %", q)
 }
 

source/codegen/dotop.cpp

@@ -62,6 +62,15 @@ CGResult sst::MethodDotOp::_codegen(cgn::CodegenState* cs, fir::Type* infer)
 		fir::Type* sty = 0;
 		auto res = getAppropriateValuePointer(cs, this, this->lhs, &sty);
 
+		if(!res->islvalue())
+		{
+			auto tmplval = cs->irb.CreateLValue(this->lhs->type);
+			cs->irb.Store(res.value, tmplval);
+
+			res.value = tmplval;
+			res->makeConst();
+		}
+
 		// then we insert it as the first argument
 		auto rv = util::pool<sst::RawValueExpr>(this->loc, res.value->getType()->getMutablePointerTo());
 		rv->rawValue = CGResult(cs->irb.AddressOf(res.value, true));

source/frontend/errors.cpp

@@ -467,6 +467,7 @@ void OverloadError::post()
 
 
 
+
 [[noreturn]] void doTheExit(bool trace)
 {
 	fprintf(stderr, "there were errors, compilation cannot continue\n");
@@ -487,3 +488,8 @@ void OverloadError::post()
 
 
 
+
+
+
+
+

source/include/utils.h

@@ -171,7 +171,13 @@ namespace util
 	template <typename T>
 	std::vector<T> take(const std::vector<T>& v, size_t num)
 	{
-		return std::vector<T>(v.begin(), v.begin() + num);
+		return std::vector<T>(v.begin(), v.begin() + std::min(num, v.size()));
+	}
+
+	template <typename T>
+	std::vector<T> drop(const std::vector<T>& v, size_t num)
+	{
+		return std::vector<T>(v.begin() + std::min(num, v.size()), v.end());
 	}
 
 	inline std::string join(const std::vector<std::string>& list, const std::string& sep)

source/typecheck/classes.cpp

@@ -209,13 +209,11 @@ TCResult ast::ClassDefn::typecheck(sst::TypecheckState* fs, fir::Type* infer, co
 					{
 						// ok -- issue is that we cannot compare the method signatures directly -- because the method will take the 'self' of its
 						// respective class, meaning they won't be duplicates. so, we must compare without the first parameter.
-
-						// note: we're passing by copy here intentionally so we can erase the first one.
-						auto compareMethods = [&fs](std::vector<FnParam> a, std::vector<FnParam> b) -> bool {
-							return fs->isDuplicateOverload(a, b);
+						auto compareMethodSignatures = [&fs](const std::vector<FnParam>& a, const std::vector<FnParam>& b) -> bool {
+							return fs->isDuplicateOverload(util::drop(a, 1), util::drop(b, 1));
 						};
 
-						if(bf->id.name == meth->id.name && compareMethods(bf->params, meth->params))
+						if(bf->id.name == meth->id.name && compareMethodSignatures(bf->params, meth->params))
 						{
 							// check for virtual functions.
 							//* note: we don't need to care if 'bf' is the base method, because if we are 'isOverride', then we are also

source/typecheck/dotop.cpp

@@ -462,8 +462,9 @@ static sst::Expr* doExpressionDotOp(sst::TypecheckState* fs, ast::DotOperator* d
 
 	// ok.
 	auto defn = fs->typeDefnMap[type];
-	iceAssert(defn);
 
+	// note: if `defn` is null, then all the dcasts will fail and we'll
+	// fallthrough to the bottom.
 	if(auto str = dcast(sst::StructDefn, defn))
 	{
 		// right.