resolc crate (#328)

- Factor the YUL crate out of `revive-solidity`.
- `revive-solidity` is in reality not a Solidity implementation but the
revive solidity compiler driver (`resolc`). By renaming we not only get
this straight but also a binary with the same name as the crate which
should be less confusing.

---------

Signed-off-by: Cyrill Leutwiler <bigcyrill@hotmail.com>

crates/yul/src/parser/statement/code.rs

@@ -0,0 +1,107 @@
+//! The YUL code.
+
+use std::collections::HashSet;
+
+use serde::Deserialize;
+use serde::Serialize;
+
+use crate::error::Error;
+use crate::lexer::token::lexeme::keyword::Keyword;
+use crate::lexer::token::lexeme::Lexeme;
+use crate::lexer::token::location::Location;
+use crate::lexer::token::Token;
+use crate::lexer::Lexer;
+use crate::parser::error::Error as ParserError;
+use crate::parser::statement::block::Block;
+
+/// The YUL code entity, which is the first block of the object.
+#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq)]
+pub struct Code {
+    /// The location.
+    pub location: Location,
+    /// The main block.
+    pub block: Block,
+}
+
+impl Code {
+    /// The element parser.
+    pub fn parse(lexer: &mut Lexer, initial: Option<Token>) -> Result<Self, Error> {
+        let token = crate::parser::take_or_next(initial, lexer)?;
+
+        let location = match token {
+            Token {
+                lexeme: Lexeme::Keyword(Keyword::Code),
+                location,
+                ..
+            } => location,
+            token => {
+                return Err(ParserError::InvalidToken {
+                    location: token.location,
+                    expected: vec!["code"],
+                    found: token.lexeme.to_string(),
+                }
+                .into());
+            }
+        };
+
+        let block = Block::parse(lexer, None)?;
+
+        Ok(Self { location, block })
+    }
+
+    /// Get the list of missing deployable libraries.
+    pub fn get_missing_libraries(&self) -> HashSet<String> {
+        self.block.get_missing_libraries()
+    }
+}
+
+impl<D> revive_llvm_context::PolkaVMWriteLLVM<D> for Code
+where
+    D: revive_llvm_context::PolkaVMDependency + Clone,
+{
+    fn into_llvm(self, context: &mut revive_llvm_context::PolkaVMContext<D>) -> anyhow::Result<()> {
+        self.block.into_llvm(context)?;
+
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::lexer::token::location::Location;
+    use crate::lexer::Lexer;
+    use crate::parser::error::Error;
+    use crate::parser::statement::object::Object;
+
+    #[test]
+    fn error_invalid_token_code() {
+        let input = r#"
+object "Test" {
+    data {
+        {
+            return(0, 0)
+        }
+    }
+    object "Test_deployed" {
+        code {
+            {
+                return(0, 0)
+            }
+        }
+    }
+}
+    "#;
+
+        let mut lexer = Lexer::new(input.to_owned());
+        let result = Object::parse(&mut lexer, None);
+        assert_eq!(
+            result,
+            Err(Error::InvalidToken {
+                location: Location::new(3, 5),
+                expected: vec!["code"],
+                found: "data".to_owned(),
+            }
+            .into())
+        );
+    }
+}