Merge pull request #4520 from onflow/supun/fix-inherited-code-from-same-contract

[Compiler] Fix compiling inherited code from same contract

Author: SupunS

bbq/compiler/compiler.go

@@ -4723,10 +4723,10 @@ func (c *Compiler[_, _]) emitConvert(valueType, targetType sema.Type) {
 
 func (c *Compiler[_, _]) getOrAddType(ty sema.Type) uint16 {
 	// When compiling an inherited code, if we come across a concrete contract type,
-	// then use a reference-type to it.
-	// An inherited code can never refer to the currently compiling contract (i.e: circular imports),
-	// so it's always safe to treat an inherited contract-variable type as a reference type.
-	if c.isInheritedCode {
+	// then use a reference-type to it if the contract is imported.
+	// Non-imported contracts (i.e: the enclosing contract of the current program) should be
+	// used as the concrete type, not as a reference.
+	if c.isInheritedCode && c.isImportedContract(ty) {
 		ty = sema.ImportedType(c.Config.MemoryGauge, ty)
 	}
 
@@ -4745,6 +4745,16 @@ func (c *Compiler[_, _]) getOrAddType(ty sema.Type) uint16 {
 	return index
 }
 
+func (c *Compiler[_, _]) isImportedContract(ty sema.Type) bool {
+	compositeType, isCompositeType := ty.(*sema.CompositeType)
+	if !isCompositeType || compositeType.Kind != common.CompositeKindContract {
+		return false
+	}
+
+	_, isImported := c.addedImports[compositeType.Location]
+	return isImported
+}
+
 func (c *Compiler[_, T]) addCompiledType(ty sema.Type, data T) uint16 {
 	count := len(c.compiledTypes)
 	if count >= math.MaxUint16 {

runtime/runtime_test.go

@@ -14037,6 +14037,12 @@ func TestRuntimeContractAccessInInheritedCode(t *testing.T) {
                     }
                 }
 
+                access(all) struct S: I {
+                    // 'foo' function has an inherited pre-condition.
+                    // It refers to the **same** contract inside the inherited code.
+                    access(all) fun test() {}
+                }
+
                 access(all) view fun someFunction(): Bool {
                     return true
                 }
@@ -14094,12 +14100,21 @@ func TestRuntimeContractAccessInInheritedCode(t *testing.T) {
             import Foo from %s
 
             access(all) struct S: Foo.I {
+                // 'foo' function has an inherited pre-condition.
+                // It refers to an **imported** contract inside the inherited code.
                 access(all) fun test() {}
             }
 
             access(all) fun main() {
+                // 'S' struct is inheriting from a type (Foo.I) defined in an imported contract.
+                // So the pre-condition 'Foo.someFunction()' should refer to 'Foo' via a reference.
                 let s = S()
                 s.test()
+
+                // 'Foo.S' struct is inheriting from a type (Foo.I) defined in the same contract.
+                // So the pre-condition 'Foo.someFunction()' should refer to 'Foo' as the concrete type.
+                let fooS = Foo.S()
+                fooS.test()
             }`,
 			addressValue.ShortHexWithPrefix(),
 		)