Rename Complement to BitwiseNot (#1255)

BitwiseNot is a much better name. Signed-off-by: Sean Young <[email protected]>
hyperledger-solang · Apr 6, 2023 · 8cc4d51 · 8cc4d51
1 parent c5afda5
commit 8cc4d51
Show file tree

Hide file tree

Showing 20 changed files with 47 additions and 48 deletions.
diff --git a/solang-parser/src/helpers/fmt.rs b/solang-parser/src/helpers/fmt.rs
@@ -555,7 +555,7 @@ impl Display for pt::Expression {
             | Self::PreDecrement(..)
             | Self::PostDecrement(..)
             | Self::Not(..)
-            | Self::Complement(..)
+            | Self::BitwiseNot(..)
             | Self::UnaryPlus(..)
             | Self::Add(..)
             | Self::Negate(..)
@@ -626,7 +626,7 @@ impl pt::Expression {
             PreDecrement(..) | PostDecrement(..) => "--",
 
             Not(..) => "!",
-            Complement(..) => "~",
+            BitwiseNot(..) => "~",
             UnaryPlus(..) | Add(..) => "+",
             Negate(..) | Subtract(..) => "-",
             Power(..) => "**",
@@ -1041,7 +1041,7 @@ impl pt::UserDefinedOperator {
     pub const fn as_str(&self) -> &'static str {
         match self {
             Self::BitwiseAnd => "&",
-            Self::Complement => "~",
+            Self::BitwiseNot => "~",
             Self::Negate => "-",
             Self::BitwiseOr => "|",
             Self::BitwiseXor => "^",
@@ -2118,7 +2118,7 @@ mod tests {
                 pt::Expression::PreDecrement(loc!(), var("a")) => "--a",
                 pt::Expression::PostDecrement(loc!(), var("a")) => "a--",
                 pt::Expression::Not(loc!(), var("a")) => "!a",
-                pt::Expression::Complement(loc!(), var("a")) => "~a",
+                pt::Expression::BitwiseNot(loc!(), var("a")) => "~a",
                 pt::Expression::UnaryPlus(loc!(), var("a")) => "+a",
                 pt::Expression::Negate(loc!(), var("a")) => "-a",
 
@@ -2426,7 +2426,7 @@ mod tests {
 
             pt::UserDefinedOperator: {
                 pt::UserDefinedOperator::BitwiseAnd => "&",
-                pt::UserDefinedOperator::Complement => "~",
+                pt::UserDefinedOperator::BitwiseNot => "~",
                 pt::UserDefinedOperator::Negate => "-",
                 pt::UserDefinedOperator::BitwiseOr => "|",
                 pt::UserDefinedOperator::BitwiseXor => "^",

diff --git a/solang-parser/src/helpers/loc.rs b/solang-parser/src/helpers/loc.rs
@@ -311,7 +311,7 @@ impl_for_enums! {
         | Self::FunctionCallBlock(l, ..)
         | Self::NamedFunctionCall(l, ..)
         | Self::Not(l, ..)
-        | Self::Complement(l, ..)
+        | Self::BitwiseNot(l, ..)
         | Self::Delete(l, ..)
         | Self::PreIncrement(l, ..)
         | Self::PreDecrement(l, ..)

diff --git a/solang-parser/src/lexer.rs b/solang-parser/src/lexer.rs
@@ -149,7 +149,7 @@ pub enum Token<'input> {
     Colon,
     OpenBracket,
     CloseBracket,
-    Complement,
+    BitwiseNot,
     Question,
 
     Mapping,
@@ -244,7 +244,7 @@ impl<'input> fmt::Display for Token<'input> {
             Token::Colon => write!(f, ":"),
             Token::OpenBracket => write!(f, "["),
             Token::CloseBracket => write!(f, "]"),
-            Token::Complement => write!(f, "~"),
+            Token::BitwiseNot => write!(f, "~"),
             Token::Question => write!(f, "?"),
             Token::ShiftRightAssign => write!(f, "<<="),
             Token::ShiftRight => write!(f, "<<"),
@@ -985,7 +985,7 @@ impl<'input> Lexer<'input> {
                 Some((i, ')')) => return Some(Ok((i, Token::CloseParenthesis, i + 1))),
                 Some((i, '{')) => return Some(Ok((i, Token::OpenCurlyBrace, i + 1))),
                 Some((i, '}')) => return Some(Ok((i, Token::CloseCurlyBrace, i + 1))),
-                Some((i, '~')) => return Some(Ok((i, Token::Complement, i + 1))),
+                Some((i, '~')) => return Some(Ok((i, Token::BitwiseNot, i + 1))),
                 Some((i, '=')) => match self.chars.peek() {
                     Some((_, '=')) => {
                         self.chars.next();

diff --git a/solang-parser/src/pt.rs b/solang-parser/src/pt.rs
@@ -580,8 +580,7 @@ pub enum UserDefinedOperator {
     BitwiseAnd,
     /// `~`
     ///
-    /// AKA BitwiseNot
-    Complement,
+    BitwiseNot,
     /// `-`
     ///
     /// Note that this is the same as `Subtract`, and that it is currently not being parsed.
@@ -619,15 +618,15 @@ impl UserDefinedOperator {
     #[inline]
     pub const fn args(&self) -> usize {
         match self {
-            UserDefinedOperator::Complement | UserDefinedOperator::Negate => 1,
+            UserDefinedOperator::BitwiseNot | UserDefinedOperator::Negate => 1,
             _ => 2,
         }
     }
 
     /// Returns whether `self` is a unary operator.
     #[inline]
     pub const fn is_unary(&self) -> bool {
-        matches!(self, Self::Complement | Self::Negate)
+        matches!(self, Self::BitwiseNot | Self::Negate)
     }
 
     /// Returns whether `self` is a binary operator.
@@ -641,7 +640,7 @@ impl UserDefinedOperator {
     pub const fn is_bitwise(&self) -> bool {
         matches!(
             self,
-            Self::BitwiseAnd | Self::BitwiseOr | Self::BitwiseXor | Self::Complement
+            Self::BitwiseAnd | Self::BitwiseOr | Self::BitwiseXor | Self::BitwiseNot
         )
     }
 
@@ -971,7 +970,7 @@ pub enum Expression {
     /// `!<1>`
     Not(Loc, Box<Expression>),
     /// `~<1>`
-    Complement(Loc, Box<Expression>),
+    BitwiseNot(Loc, Box<Expression>),
     /// `delete <1>`
     Delete(Loc, Box<Expression>),
     /// `++<1>`
@@ -1089,7 +1088,7 @@ macro_rules! expr_components {
 
             // (None, Some)
             Not(_, expr)
-            | Complement(_, expr)
+            | BitwiseNot(_, expr)
             | New(_, expr)
             | Delete(_, expr)
             | UnaryPlus(_, expr)
@@ -1242,7 +1241,7 @@ impl Expression {
                 | PostDecrement(..)
                 | PreDecrement(..)
                 | Not(..)
-                | Complement(..)
+                | BitwiseNot(..)
                 | UnaryPlus(..)
                 | Negate(..)
         )

diff --git a/solang-parser/src/solidity.lalrpop b/solang-parser/src/solidity.lalrpop
@@ -393,7 +393,7 @@ Precedence3: Expression = {
 
 Precedence2: Expression = {
     <a:@L> "!" <e:Precedence2> <b:@R> => Expression::Not(Loc::File(file_no, a, b), Box::new(e)),
-    <a:@L> "~" <e:Precedence2> <b:@R> => Expression::Complement(Loc::File(file_no, a, b), Box::new(e)),
+    <a:@L> "~" <e:Precedence2> <b:@R> => Expression::BitwiseNot(Loc::File(file_no, a, b), Box::new(e)),
     <a:@L> "delete" <e:Precedence2> <b:@R>  => Expression::Delete(Loc::File(file_no, a, b), Box::new(e)),
     <a:@L> "new" <call:Precedence2> <b:@R> => Expression::New(Loc::File(file_no, a, b), Box::new(call)),
     <a:@L> "++" <e:Precedence2> <b:@R> => Expression::PreIncrement(Loc::File(file_no, a, b), Box::new(e)),
@@ -738,7 +738,7 @@ UsingFunction: UsingFunction = {
 
 UserDefinedOperator: UserDefinedOperator = {
     "as" "&" => UserDefinedOperator::BitwiseAnd,
-    "as" "~" => UserDefinedOperator::Complement,
+    "as" "~" => UserDefinedOperator::BitwiseNot,
     "as" "|" => UserDefinedOperator::BitwiseOr,
     "as" "^" => UserDefinedOperator::BitwiseXor,
     "as" "+" => UserDefinedOperator::Add,
@@ -1117,7 +1117,7 @@ extern {
         "%" => Token::Modulo,
         "**" => Token::Power,
         "!" => Token::Not,
-        "~" => Token::Complement,
+        "~" => Token::BitwiseNot,
         "++" => Token::Increment,
         "--" => Token::Decrement,
         "[" => Token::OpenBracket,

diff --git a/src/bin/languageserver/mod.rs b/src/bin/languageserver/mod.rs
@@ -583,7 +583,7 @@ impl<'a> Builder<'a> {
             | ast::Expression::PostDecrement { expr, .. }
             // Other Unary
             | ast::Expression::Not { expr, .. }
-            | ast::Expression::Complement { expr, .. }
+            | ast::Expression::BitwiseNot { expr, .. }
             | ast::Expression::Negate { expr, .. } => {
                 self.expression(expr, symtab);
             }

diff --git a/src/codegen/cfg.rs b/src/codegen/cfg.rs
@@ -783,7 +783,7 @@ impl ControlFlowGraph {
                 f
             ),
             Expression::Not(_, e) => format!("!{}", self.expr_to_string(contract, ns, e)),
-            Expression::Complement(_, _, e) => format!("~{}", self.expr_to_string(contract, ns, e)),
+            Expression::BitwiseNot(_, _, e) => format!("~{}", self.expr_to_string(contract, ns, e)),
             Expression::Negate(_, _, e) => format!("-{}", self.expr_to_string(contract, ns, e)),
             Expression::Poison => "☠".to_string(),
             Expression::AllocDynamicBytes(_, ty, size, None) => {

diff --git a/src/codegen/constant_folding.rs b/src/codegen/constant_folding.rs
@@ -667,13 +667,13 @@ fn expression(
                 )
             }
         }
-        Expression::Complement(loc, ty, expr) => {
+        Expression::BitwiseNot(loc, ty, expr) => {
             let expr = expression(expr, vars, cfg, ns);
             if let Expression::NumberLiteral(_, _, n) = expr.0 {
                 bigint_to_expression(loc, ty, !n)
             } else {
                 (
-                    Expression::Complement(*loc, ty.clone(), Box::new(expr.0)),
+                    Expression::BitwiseNot(*loc, ty.clone(), Box::new(expr.0)),
                     expr.1,
                 )
             }

diff --git a/src/codegen/expression.rs b/src/codegen/expression.rs
@@ -289,7 +289,7 @@ pub fn expression(
             *loc,
             Box::new(expression(expr, cfg, contract_no, func, ns, vartab, opt)),
         ),
-        ast::Expression::Complement { loc, ty, expr } => Expression::Complement(
+        ast::Expression::BitwiseNot { loc, ty, expr } => Expression::BitwiseNot(
             *loc,
             ty.clone(),
             Box::new(expression(expr, cfg, contract_no, func, ns, vartab, opt)),

diff --git a/src/codegen/mod.rs b/src/codegen/mod.rs
@@ -351,7 +351,7 @@ pub enum Expression {
     BytesCast(pt::Loc, Type, Type, Box<Expression>),
     BytesLiteral(pt::Loc, Type, Vec<u8>),
     Cast(pt::Loc, Type, Box<Expression>),
-    Complement(pt::Loc, Type, Box<Expression>),
+    BitwiseNot(pt::Loc, Type, Box<Expression>),
     ConstArrayLiteral(pt::Loc, Type, Vec<u32>, Vec<Expression>),
     UnsignedDivide(pt::Loc, Type, Box<Expression>, Box<Expression>),
     SignedDivide(pt::Loc, Type, Box<Expression>, Box<Expression>),
@@ -465,7 +465,7 @@ impl CodeLocation for Expression {
             | Expression::BitwiseXor(loc, ..)
             | Expression::Equal(loc, ..)
             | Expression::NotEqual(loc, ..)
-            | Expression::Complement(loc, ..)
+            | Expression::BitwiseNot(loc, ..)
             | Expression::Negate(loc, ..)
             | Expression::Less { loc, .. }
             | Expression::Not(loc, ..)
@@ -535,7 +535,7 @@ impl Recurse for Expression {
             | Expression::Negate(_, _, exp)
             | Expression::ZeroExt(_, _, exp)
             | Expression::SignExt(_, _, exp)
-            | Expression::Complement(_, _, exp)
+            | Expression::BitwiseNot(_, _, exp)
             | Expression::Load(_, _, exp)
             | Expression::StorageArrayLength { array: exp, .. }
             | Expression::StructMember(_, _, exp, _)
@@ -607,7 +607,7 @@ impl RetrieveType for Expression {
             | Expression::BitwiseXor(_, ty, ..)
             | Expression::ShiftLeft(_, ty, ..)
             | Expression::ShiftRight(_, ty, ..)
-            | Expression::Complement(_, ty, ..)
+            | Expression::BitwiseNot(_, ty, ..)
             | Expression::StorageArrayLength { ty, .. }
             | Expression::Negate(_, ty, ..)
             | Expression::StructLiteral(_, ty, ..)
@@ -1146,8 +1146,8 @@ impl Expression {
                     bytes_offset: Box::new(filter(offset, ctx)),
                 },
                 Expression::Not(loc, expr) => Expression::Not(*loc, Box::new(filter(expr, ctx))),
-                Expression::Complement(loc, ty, expr) => {
-                    Expression::Complement(*loc, ty.clone(), Box::new(filter(expr, ctx)))
+                Expression::BitwiseNot(loc, ty, expr) => {
+                    Expression::BitwiseNot(*loc, ty.clone(), Box::new(filter(expr, ctx)))
                 }
                 Expression::Negate(loc, ty, expr) => {
                     Expression::Negate(*loc, ty.clone(), Box::new(filter(expr, ctx)))

diff --git a/src/codegen/strength_reduce/expression_values.rs b/src/codegen/strength_reduce/expression_values.rs
@@ -58,7 +58,7 @@ pub(super) fn expression_values(
             not_equal_values(left_expr, right_expr, vars, ns)
         }
         Expression::Not(_, expr) => not_values(expr, vars, ns),
-        Expression::Complement(_, _, expr) => complement_values(expr, vars, ns),
+        Expression::BitwiseNot(_, _, expr) => complement_values(expr, vars, ns),
         Expression::Variable(_, _, var_no) => variable_values(*var_no, vars),
         Expression::InternalFunctionCfg(_) => {
             // reference to a function; ignore

diff --git a/src/codegen/subexpression_elimination/expression.rs b/src/codegen/subexpression_elimination/expression.rs
@@ -208,8 +208,8 @@ impl Expression {
 
             Expression::Not(loc, ..) => Expression::Not(*loc, Box::new(operand.clone())),
 
-            Expression::Complement(loc, expr_type, ..) => {
-                Expression::Complement(*loc, expr_type.clone(), Box::new(operand.clone()))
+            Expression::BitwiseNot(loc, expr_type, ..) => {
+                Expression::BitwiseNot(*loc, expr_type.clone(), Box::new(operand.clone()))
             }
 
             Expression::Negate(loc, expr_type, ..) => {
@@ -268,7 +268,7 @@ impl Expression {
             | Expression::Cast(_, _, operand)
             | Expression::BytesCast(_, _, _, operand)
             | Expression::Not(_, operand)
-            | Expression::Complement(_, _, operand)
+            | Expression::BitwiseNot(_, _, operand)
             | Expression::Negate(_, _, operand) => Some(operand),
 
             _ => None,

diff --git a/src/codegen/subexpression_elimination/operator.rs b/src/codegen/subexpression_elimination/operator.rs
@@ -46,7 +46,7 @@ pub enum Operator {
     Cast(Type),
     BytesCast,
     Negate,
-    Complement,
+    BitwiseNot,
 }
 
 impl Expression {
@@ -108,7 +108,7 @@ impl Expression {
             Expression::LessEqual { signed: false, .. } => Operator::UnsignedLessEqual,
             Expression::Equal(..) => Operator::Equal,
             Expression::NotEqual(..) => Operator::NotEqual,
-            Expression::Complement(..) => Operator::Complement,
+            Expression::BitwiseNot(..) => Operator::BitwiseNot,
             Expression::StringCompare(..) => Operator::StringCompare,
             Expression::StringConcat(..) => Operator::StringConcat,
             Expression::AdvancePointer { .. } => Operator::AdvancePointer,

diff --git a/src/codegen/yul/builtin.rs b/src/codegen/yul/builtin.rs
@@ -47,7 +47,7 @@ pub(crate) fn process_builtin(
     match builtin_ty {
         YulBuiltInFunction::Not => {
             let exp = expression(&args[0], contract_no, ns, vartab, cfg, opt);
-            Expression::Complement(*loc, exp.ty(), Box::new(exp))
+            Expression::BitwiseNot(*loc, exp.ty(), Box::new(exp))
         }
 
         YulBuiltInFunction::IsZero => {

diff --git a/src/emit/expression.rs b/src/emit/expression.rs
@@ -1083,7 +1083,7 @@ pub(super) fn expression<'a, T: TargetRuntime<'a> + ?Sized>(
                 .build_int_compare(IntPredicate::EQ, e, e.get_type().const_zero(), "")
                 .into()
         }
-        Expression::Complement(_, _, e) => {
+        Expression::BitwiseNot(_, _, e) => {
             let e = expression(target, bin, e, vartab, function, ns).into_int_value();
 
             bin.builder.build_not(e, "").into()

diff --git a/src/sema/ast.rs b/src/sema/ast.rs
@@ -1014,7 +1014,7 @@ pub enum Expression {
         loc: pt::Loc,
         expr: Box<Expression>,
     },
-    Complement {
+    BitwiseNot {
         loc: pt::Loc,
         ty: Type,
         expr: Box<Expression>,
@@ -1200,7 +1200,7 @@ impl Recurse for Expression {
                 | Expression::PostIncrement { expr, .. }
                 | Expression::PostDecrement { expr, .. }
                 | Expression::Not { expr, .. }
-                | Expression::Complement { expr, .. }
+                | Expression::BitwiseNot { expr, .. }
                 | Expression::Negate { expr, .. }
                 | Expression::StructMember { expr, .. } => expr.recurse(cx, f),
 
@@ -1357,7 +1357,7 @@ impl CodeLocation for Expression {
             | Expression::Equal { loc, .. }
             | Expression::NotEqual { loc, .. }
             | Expression::Not { loc, expr: _ }
-            | Expression::Complement { loc, .. }
+            | Expression::BitwiseNot { loc, .. }
             | Expression::Negate { loc, .. }
             | Expression::ConditionalOperator { loc, .. }
             | Expression::Subscript { loc, .. }

diff --git a/src/sema/dotgraphviz.rs b/src/sema/dotgraphviz.rs
@@ -953,7 +953,7 @@ impl Dot {
 
                 self.add_expression(expr, func, ns, node, String::from("expr"));
             }
-            Expression::Complement { loc, ty, expr } => {
+            Expression::BitwiseNot { loc, ty, expr } => {
                 let node = self.add_node(
                     Node::new(
                         "complement",

diff --git a/src/sema/eval.rs b/src/sema/eval.rs
@@ -133,7 +133,7 @@ pub fn eval_const_number(
         Expression::SignExt { loc, expr, .. } => Ok((*loc, eval_const_number(expr, ns)?.1)),
         Expression::Cast { loc, expr, .. } => Ok((*loc, eval_const_number(expr, ns)?.1)),
         Expression::Not { loc, expr: n } => Ok((*loc, !eval_const_number(n, ns)?.1)),
-        Expression::Complement { loc, expr, .. } => Ok((*loc, !eval_const_number(expr, ns)?.1)),
+        Expression::BitwiseNot { loc, expr, .. } => Ok((*loc, !eval_const_number(expr, ns)?.1)),
         Expression::Negate { loc, expr, .. } => Ok((*loc, -eval_const_number(expr, ns)?.1)),
         Expression::ConstantVariable {
             contract_no: Some(contract_no),

diff --git a/src/sema/expression/resolve_expression.rs b/src/sema/expression/resolve_expression.rs
@@ -343,15 +343,15 @@ pub fn expression(
                 expr: Box::new(expr.cast(loc, &Type::Bool, true, ns, diagnostics)?),
             })
         }
-        pt::Expression::Complement(loc, e) => {
+        pt::Expression::BitwiseNot(loc, e) => {
             let expr = expression(e, context, ns, symtable, diagnostics, resolve_to)?;
 
             used_variable(ns, &expr, symtable);
 
             if let Some(expr) = user_defined_operator(
                 loc,
                 &[&expr],
-                pt::UserDefinedOperator::Complement,
+                pt::UserDefinedOperator::BitwiseNot,
                 diagnostics,
                 ns,
             ) {
@@ -362,7 +362,7 @@ pub fn expression(
 
             get_int_length(&expr_ty, loc, true, ns, diagnostics)?;
 
-            Ok(Expression::Complement {
+            Ok(Expression::BitwiseNot {
                 loc: *loc,
                 ty: expr_ty,
                 expr: Box::new(expr),