Add support for interfaceID.

Changelog.md

@@ -7,7 +7,7 @@ Language Features:
 
 
 Compiler Features:
-
+ * Add support for EIP 165 interface identifiers with `type(I).interfaceId`.
 
 Bugfixes:
  * AST export: Export `immutable` property in the field `mutability`.

docs/units-and-global-variables.rst

@@ -310,3 +310,12 @@ available for a contract type ``C``:
     regular calls.
     The same restrictions as with ``.creationCode`` also apply for this
     property.
+
+In addition to the properties above, the following properties are available
+for an interface type ``I``:
+
+``type(I).interfaceId``:
+    This property returns the `EIP-165 <https://eips.ethereum.org/EIPS/eip-165>`_
+    interface identifier of the given interface ``I``. This identifier is defined as the ``XOR`` of all
+    function selectors defined within the interface itself - excluding all inherited functions.
+    The returned interface identifier is of type ``bytes4``.

libsolidity/analysis/TypeChecker.cpp

@@ -2617,6 +2617,8 @@ bool TypeChecker::visit(MemberAccess const& _memberAccess)
 		}
 		else if (magicType->kind() == MagicType::Kind::MetaType && memberName == "name")
 			annotation.isPure = true;
+		else if (magicType->kind() == MagicType::Kind::MetaType && memberName == "interfaceId")
+			annotation.isPure = true;
 	}
 
 	return false;

libsolidity/analysis/ViewPureChecker.cpp

@@ -355,6 +355,7 @@ void ViewPureChecker::endVisit(MemberAccess const& _memberAccess)
 			{MagicType::Kind::MetaType, "creationCode"},
 			{MagicType::Kind::MetaType, "runtimeCode"},
 			{MagicType::Kind::MetaType, "name"},
+			{MagicType::Kind::MetaType, "interfaceId"},
 		};
 		set<MagicMember> static const payableMembers{
 			{MagicType::Kind::Message, "value"}

libsolidity/ast/AST.cpp

@@ -96,9 +96,9 @@ bool ContractDefinition::derivesFrom(ContractDefinition const& _base) const
 	return util::contains(annotation().linearizedBaseContracts, &_base);
 }
 
-map<util::FixedHash<4>, FunctionTypePointer> ContractDefinition::interfaceFunctions() const
+map<util::FixedHash<4>, FunctionTypePointer> ContractDefinition::interfaceFunctions(bool _includeInheritedFunctions) const
 {
-	auto exportedFunctionList = interfaceFunctionList();
+	auto exportedFunctionList = interfaceFunctionList(_includeInheritedFunctions);
 
 	map<util::FixedHash<4>, FunctionTypePointer> exportedFunctions;
 	for (auto const& it: exportedFunctionList)
@@ -174,14 +174,16 @@ vector<EventDefinition const*> const& ContractDefinition::interfaceEvents() cons
 	return *m_interfaceEvents;
 }
 
-vector<pair<util::FixedHash<4>, FunctionTypePointer>> const& ContractDefinition::interfaceFunctionList() const
+vector<pair<util::FixedHash<4>, FunctionTypePointer>> const& ContractDefinition::interfaceFunctionList(bool _includeDerivedFunctions) const
 {
-	if (!m_interfaceFunctionList)
+	if (!m_interfaceFunctionList[_includeDerivedFunctions])
 	{
 		set<string> signaturesSeen;
-		m_interfaceFunctionList = make_unique<vector<pair<util::FixedHash<4>, FunctionTypePointer>>>();
+		m_interfaceFunctionList[_includeDerivedFunctions] = make_unique<vector<pair<util::FixedHash<4>, FunctionTypePointer>>>();
 		for (ContractDefinition const* contract: annotation().linearizedBaseContracts)
 		{
+			if (_includeDerivedFunctions == false && contract != this)
+				continue;
 			vector<FunctionTypePointer> functions;
 			for (FunctionDefinition const* f: contract->definedFunctions())
 				if (f->isPartOfExternalInterface())
@@ -199,12 +201,12 @@ vector<pair<util::FixedHash<4>, FunctionTypePointer>> const& ContractDefinition:
 				{
 					signaturesSeen.insert(functionSignature);
 					util::FixedHash<4> hash(util::keccak256(functionSignature));
-					m_interfaceFunctionList->emplace_back(hash, fun);
+					m_interfaceFunctionList[_includeDerivedFunctions]->emplace_back(hash, fun);
 				}
 			}
 		}
 	}
-	return *m_interfaceFunctionList;
+	return *m_interfaceFunctionList[_includeDerivedFunctions];
 }
 
 TypePointer ContractDefinition::type() const

libsolidity/ast/AST.h

@@ -488,8 +488,8 @@ class ContractDefinition: public Declaration, public StructurallyDocumented
 
 	/// @returns a map of canonical function signatures to FunctionDefinitions
 	/// as intended for use by the ABI.
-	std::map<util::FixedHash<4>, FunctionTypePointer> interfaceFunctions() const;
-	std::vector<std::pair<util::FixedHash<4>, FunctionTypePointer>> const& interfaceFunctionList() const;
+	std::map<util::FixedHash<4>, FunctionTypePointer> interfaceFunctions(bool _includeInheritedFunctions = true) const;
+	std::vector<std::pair<util::FixedHash<4>, FunctionTypePointer>> const& interfaceFunctionList(bool _includeDerivedFunctions = true) const;
 
 	/// @returns a list of all declarations in this contract
 	std::vector<Declaration const*> declarations() const { return filteredNodes<Declaration>(m_subNodes); }
@@ -528,7 +528,7 @@ class ContractDefinition: public Declaration, public StructurallyDocumented
 	ContractKind m_contractKind;
 	bool m_abstract{false};
 
-	mutable std::unique_ptr<std::vector<std::pair<util::FixedHash<4>, FunctionTypePointer>>> m_interfaceFunctionList;
+	mutable std::unique_ptr<std::vector<std::pair<util::FixedHash<4>, FunctionTypePointer>>> m_interfaceFunctionList[2];
 	mutable std::unique_ptr<std::vector<EventDefinition const*>> m_interfaceEvents;
 };
 

libsolidity/ast/Types.cpp

@@ -3719,7 +3719,9 @@ MemberList::MemberMap MagicType::nativeMembers(ContractDefinition const*) const
 				{"name", TypeProvider::stringMemory()},
 			});
 		else
-			return {};
+			return MemberList::MemberMap({
+				{"interfaceId", TypeProvider::fixedBytes(4)},
+			});
 	}
 	}
 	solAssert(false, "Unknown kind of magic.");

libsolidity/codegen/ExpressionCompiler.cpp

@@ -1580,6 +1580,15 @@ bool ExpressionCompiler::visit(MemberAccess const& _memberAccess)
 			m_context << Instruction::DUP1 << u256(32) << Instruction::ADD;
 			utils().storeStringData(contract.name());
 		}
+		else if (member == "interfaceId")
+		{
+			TypePointer arg = dynamic_cast<MagicType const&>(*_memberAccess.expression().annotation().type).typeArgument();
+			ContractDefinition const& contract = dynamic_cast<ContractType const&>(*arg).contractDefinition();
+			uint64_t result{0};
+			for (auto const& function: contract.interfaceFunctionList(false))
+				result ^= fromBigEndian<uint64_t>(function.first.ref());
+			m_context << (u256{result} << (256 - 32));
+		}
 		else if ((set<string>{"encode", "encodePacked", "encodeWithSelector", "encodeWithSignature", "decode"}).count(member))
 		{
 			// no-op

libsolidity/codegen/ir/IRGeneratorForStatements.cpp

@@ -754,6 +754,10 @@ void IRGeneratorForStatements::endVisit(FunctionCall const& _functionCall)
 		}
 		break;
 	}
+	case FunctionType::Kind::MetaType:
+	{
+		break;
+	}
 	default:
 		solUnimplemented("FunctionKind " + toString(static_cast<int>(functionType->kind())) + " not yet implemented");
 	}
@@ -904,6 +908,15 @@ void IRGeneratorForStatements::endVisit(MemberAccess const& _memberAccess)
 		{
 			solUnimplementedAssert(false, "");
 		}
+		else if (member == "interfaceId")
+		{
+			TypePointer arg = dynamic_cast<MagicType const&>(*_memberAccess.expression().annotation().type).typeArgument();
+			ContractDefinition const& contract = dynamic_cast<ContractType const&>(*arg).contractDefinition();
+			uint64_t result{0};
+			for (auto const& function: contract.interfaceFunctionList(false))
+				result ^= fromBigEndian<uint64_t>(function.first.ref());
+			define(_memberAccess) << formatNumber(u256{result} << (256 - 32)) << "\n";
+		}
 		else if (set<string>{"encode", "encodePacked", "encodeWithSelector", "encodeWithSignature", "decode"}.count(member))
 		{
 			// no-op

test/libsolidity/semanticTests/interfaceID/interfaces.sol

@@ -0,0 +1,67 @@
+interface HelloWorld {
+    function hello() external pure;
+    function world(int) external pure;
+}
+
+interface HelloWorldDerived is HelloWorld {
+    function other() external pure;
+}
+
+interface ERC165 {
+    /// @notice Query if a contract implements an interface
+    /// @param interfaceID The interface identifier, as specified in ERC-165
+    /// @dev Interface identification is specified in ERC-165. This function
+    ///  uses less than 30,000 gas.
+    /// @return `true` if the contract implements `interfaceID` and
+    ///  `interfaceID` is not 0xffffffff, `false` otherwise
+    function supportsInterface(bytes4 interfaceID) external view returns (bool);
+}
+
+contract Test {
+    bytes4 public ghello_world_interfaceId = type(HelloWorld).interfaceId;
+    bytes4 public ERC165_interfaceId = type(ERC165).interfaceId;
+
+    function hello() public pure returns (bytes4 data){
+        HelloWorld i;
+        return i.hello.selector;
+    }
+
+    function world() public pure returns (bytes4 data){
+        HelloWorld i;
+        return i.world.selector;
+    }
+
+    function hello_world() public pure returns (bytes4 data){
+        // HelloWorld i;
+        // return i.hello.selector ^ i.world.selector; // = 0xc6be8b58
+        return 0xc6be8b58;
+    }
+
+    function hello_world_interfaceId() public pure returns (bytes4 data){
+        return type(HelloWorld).interfaceId;
+    }
+
+    function other() public pure returns (bytes4 data){
+        HelloWorldDerived i;
+        return i.other.selector;
+    }
+
+    function hello_world_derived_interfaceId() public pure returns (bytes4 data){
+        return type(HelloWorldDerived).interfaceId;
+    }
+}
+
+// ====
+// compileViaYul: also
+// ----
+// hello() -> left(0x19ff1d21)
+// world() -> left(0xdf419679)
+//
+// ERC165_interfaceId() -> left(0x01ffc9a7)
+//
+// hello_world()              -> left(0xc6be8b58)
+// hello_world_interfaceId()  -> left(0xc6be8b58)
+// ghello_world_interfaceId() -> left(0xc6be8b58)
+//
+// other() -> left(0x85295877)
+// hello_world_derived_interfaceId() -> left(0x85295877)