constructors do not need a visibility specifiers

Since solidity 0.7.

Signed-off-by: Sean Young <sean@mess.org>

examples/flipper.sol

@@ -2,7 +2,7 @@ contract flipper {
 	bool private value;
 
 	/// Constructor that initializes the `bool` value to the given `init_value`.
-	constructor(bool initvalue) public {
+	constructor(bool initvalue) {
 		value = initvalue;
 	}
 

examples/full_example.sol

@@ -26,7 +26,7 @@ contract full_example {
 	int32 constant first_pid = 1;
 
 	// Our constructors
-	constructor(int32 _pid) public {
+	constructor(int32 _pid) {
 		// Set contract storage
 		pid = _pid;
 	}

examples/incrementer.sol

@@ -4,7 +4,7 @@ contract incrementer {
 	uint32 private value;
 
 	/// Constructor that initializes the `int32` value to the given `init_value`.
-	constructor(uint32 initvalue) public {
+	constructor(uint32 initvalue) {
 		value = initvalue;
 	}
 

src/abi/ethereum.rs

@@ -24,7 +24,7 @@ pub struct ABI {
     // outputs should be skipped if ty is constructor
     pub outputs: Vec<ABIParam>,
     #[serde(rename = "stateMutability")]
-    pub mutability: &'static str,
+    pub mutability: String,
 }
 
 impl Type {

src/parser/pt.rs

@@ -360,15 +360,17 @@ pub enum StateMutability {
     Payable(Loc),
 }
 
-impl StateMutability {
-    pub fn to_string(&self) -> &'static str {
+impl fmt::Display for StateMutability {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            StateMutability::Pure(_) => "pure",
-            StateMutability::View(_) => "view",
-            StateMutability::Payable(_) => "payable",
+            StateMutability::Pure(_) => write!(f, "pure"),
+            StateMutability::View(_) => write!(f, "view"),
+            StateMutability::Payable(_) => write!(f, "payable"),
         }
     }
+}
 
+impl StateMutability {
     pub fn loc(&self) -> Loc {
         match self {
             StateMutability::Pure(loc)
@@ -386,16 +388,18 @@ pub enum Visibility {
     Private(Loc),
 }
 
-impl Visibility {
-    pub fn to_string(&self) -> &'static str {
+impl fmt::Display for Visibility {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            Visibility::Public(_) => "public",
-            Visibility::External(_) => "external",
-            Visibility::Internal(_) => "internal",
-            Visibility::Private(_) => "private",
+            Visibility::Public(_) => write!(f, "public"),
+            Visibility::External(_) => write!(f, "external"),
+            Visibility::Internal(_) => write!(f, "internal"),
+            Visibility::Private(_) => write!(f, "private"),
         }
     }
+}
 
+impl Visibility {
     pub fn loc(&self) -> Loc {
         match self {
             Visibility::Public(loc)

src/sema/ast.rs

@@ -241,10 +241,10 @@ impl Function {
     }
 
     /// State mutability as string
-    pub fn print_mutability(&self) -> &'static str {
+    pub fn print_mutability(&self) -> String {
         match &self.mutability {
-            None => "nonpayable",
-            Some(m) => m.to_string(),
+            None => "nonpayable".to_string(),
+            Some(m) => format!("{}", m),
         }
     }
 }

src/sema/functions.rs

@@ -200,13 +200,27 @@ pub fn function_decl(
     }
 
     let visibility = match visibility {
-        Some(v) => v,
+        Some(v) => {
+            if func.ty == pt::FunctionTy::Constructor {
+                ns.diagnostics.push(Diagnostic::warning(
+                    v.loc(),
+                    format!("‘{}’: visibility for constructors is ignored", v),
+                ));
+
+                pt::Visibility::Public(v.loc())
+            } else {
+                v
+            }
+        }
         None => {
-            ns.diagnostics.push(Diagnostic::error(
-                func.loc,
-                "no visibility specified".to_string(),
-            ));
-            success = false;
+            if func.ty != pt::FunctionTy::Constructor {
+                ns.diagnostics.push(Diagnostic::error(
+                    func.loc,
+                    "no visibility specified".to_string(),
+                ));
+
+                success = false;
+            }
             // continue processing while assuming it's a public
             pt::Visibility::Public(pt::Loc(0, 0, 0))
         }
@@ -310,18 +324,6 @@ pub fn function_decl(
             }
         }
 
-        // FIXME: Internal visibility is allowed on abstract contracts, but we don't support those yet
-        match fdecl.visibility {
-            pt::Visibility::Public(_) => (),
-            _ => {
-                ns.diagnostics.push(Diagnostic::error(
-                    func.loc,
-                    "constructor function must be declared public".to_owned(),
-                ));
-                return None;
-            }
-        }
-
         match fdecl.mutability {
             Some(pt::StateMutability::Pure(loc)) => {
                 ns.diagnostics.push(Diagnostic::error(

tests/substrate_functions/mod.rs

@@ -6,6 +6,19 @@ use solang::Target;
 
 #[test]
 fn constructors() {
+    let ns = parse_and_resolve(
+        r##"
+        contract test {
+            constructor() internal {}
+        }"##,
+        Target::Substrate,
+    );
+
+    assert_eq!(
+        first_warning(ns.diagnostics),
+        "‘internal’: visibility for constructors is ignored"
+    );
+
     #[derive(Debug, PartialEq, Encode, Decode)]
     struct Val(u64);