Clarity Value Serialization and Name String Guarding

src/vm/analysis/build_contract_interface/mod.rs

@@ -1,5 +1,6 @@
 use vm::analysis::types::ContractAnalysis;
 use std::collections::{BTreeMap, BTreeSet};
+use vm::{ClarityName};
 use vm::types::{TypeSignature, FunctionArg, AtomTypeIdentifier, TupleTypeSignature, FunctionType};
 
 pub fn build_contract_interface(contract_analysis: &ContractAnalysis) -> ContractInterface {
@@ -16,41 +17,42 @@ pub fn build_contract_interface(contract_analysis: &ContractAnalysis) -> Contrac
         non_fungible_tokens,
         top_level_expression_sorting: _,
         expressions: _,
+        type_map: _,
     } = contract_analysis;
 
     contract_interface.functions.append(
         &mut ContractInterfaceFunction::from_map(
-            &private_function_types, 
+            private_function_types, 
             ContractInterfaceFunctionAccess::private));
 
     contract_interface.functions.append(
         &mut ContractInterfaceFunction::from_map(
-            &public_function_types, 
+            public_function_types, 
             ContractInterfaceFunctionAccess::public));
 
     contract_interface.functions.append(
         &mut ContractInterfaceFunction::from_map(
-            &contract_analysis.read_only_function_types, 
+            read_only_function_types, 
             ContractInterfaceFunctionAccess::read_only));
 
     contract_interface.variables.append(
         &mut ContractInterfaceVariable::from_map(
-            &variable_types, 
+            variable_types, 
             ContractInterfaceVariableAccess::constant));
 
     contract_interface.variables.append(
         &mut ContractInterfaceVariable::from_map(
-            &persisted_variable_types, 
+            persisted_variable_types, 
             ContractInterfaceVariableAccess::variable));
 
     contract_interface.maps.append(
-        &mut ContractInterfaceMap::from_map(&map_types));
+        &mut ContractInterfaceMap::from_map(map_types));
 
     contract_interface.non_fungible_tokens.append(
-        &mut ContractInterfaceNonFungibleTokens::from_map(&non_fungible_tokens));
+        &mut ContractInterfaceNonFungibleTokens::from_map(non_fungible_tokens));
 
     contract_interface.fungible_tokens.append(
-        &mut ContractInterfaceFungibleTokens::from_set(&fungible_tokens));
+        &mut ContractInterfaceFungibleTokens::from_set(fungible_tokens));
 
     contract_interface
 }
@@ -142,9 +144,9 @@ impl ContractInterfaceAtomType {
             TypeSignature::Atom(atom_type) => {
                 Self::from_atom_type(atom_type)
             },
-            TypeSignature::List(atom_type, list_data) => {
+            TypeSignature::List(list_data) => {
                 ContractInterfaceAtomType::list {
-                    type_f: Box::new(Self::from_atom_type(atom_type)),
+                    type_f: Box::new(Self::from_atom_type(&list_data.atomic_type)),
                     length: list_data.max_len,
                     dimension: list_data.dimension
                 }
@@ -188,10 +190,10 @@ pub struct ContractInterfaceFunction {
 }
 
 impl ContractInterfaceFunction {
-    pub fn from_map(map: &BTreeMap<String, FunctionType>, access: ContractInterfaceFunctionAccess) -> Vec<ContractInterfaceFunction> {
+    pub fn from_map(map: &BTreeMap<ClarityName, FunctionType>, access: ContractInterfaceFunctionAccess) -> Vec<ContractInterfaceFunction> {
         map.iter().map(|(name, function_type)| {
             ContractInterfaceFunction {
-                name: name.to_string(),
+                name: name.clone().into(),
                 access: access.to_owned(),
                 outputs: ContractInterfaceFunctionOutput { 
                     type_f: match function_type {
@@ -229,26 +231,26 @@ pub struct ContractInterfaceVariable {
 }
 
 impl ContractInterfaceFungibleTokens {
-    pub fn from_set(tokens: &BTreeSet<String>) -> Vec<Self> {
+    pub fn from_set(tokens: &BTreeSet<ClarityName>) -> Vec<Self> {
         tokens.iter().map(|name| Self { name: name.to_string() }).collect()
     }
 }
 
 impl ContractInterfaceNonFungibleTokens {
-    pub fn from_map(assets: &BTreeMap<String, TypeSignature>) -> Vec<Self> {
+    pub fn from_map(assets: &BTreeMap<ClarityName, TypeSignature>) -> Vec<Self> {
         assets.iter().map(|(name, type_sig)| 
                           Self { 
-                              name: name.to_string(),
+                              name: name.clone().into(),
                               type_f: ContractInterfaceAtomType::from_type_signature(type_sig)
                           }).collect()
     }
 }
 
 impl ContractInterfaceVariable {
-    pub fn from_map(map: &BTreeMap<String, TypeSignature>, access: ContractInterfaceVariableAccess) -> Vec<ContractInterfaceVariable> {
+    pub fn from_map(map: &BTreeMap<ClarityName, TypeSignature>, access: ContractInterfaceVariableAccess) -> Vec<ContractInterfaceVariable> {
         map.iter().map(|(name, type_sig)| {
             ContractInterfaceVariable {
-                name: name.to_string(),
+                name: name.clone().into(),
                 access: access.to_owned(),
                 type_f: ContractInterfaceAtomType::from_type_signature(type_sig),
             }
@@ -264,7 +266,7 @@ pub struct ContractInterfaceMap {
 }
 
 impl ContractInterfaceMap {
-    pub fn from_map(map: &BTreeMap<String, (TypeSignature, TypeSignature)>) -> Vec<ContractInterfaceMap> {
+    pub fn from_map(map: &BTreeMap<ClarityName, (TypeSignature, TypeSignature)>) -> Vec<ContractInterfaceMap> {
         map.iter().map(|(name, (key_sig, val_sig))| {
 
             let key_type = match key_sig {
@@ -278,7 +280,7 @@ impl ContractInterfaceMap {
             };
 
             ContractInterfaceMap {
-                name: name.to_string(),
+                name: name.clone().into(),
                 key: key_type,
                 value: val_type,
             }

src/vm/analysis/definition_sorter/mod.rs

@@ -1,6 +1,6 @@
 use std::collections::{HashSet, HashMap};
 use std::iter::FromIterator;
-use vm::representations::{SymbolicExpression};
+use vm::representations::{SymbolicExpression, ClarityName};
 use vm::representations::SymbolicExpressionType::{AtomValue, Atom, List};
 use vm::functions::NativeFunctions;
 use vm::functions::define::DefineFunctions;
@@ -14,7 +14,7 @@ mod tests;
 
 pub struct DefinitionSorter {
     graph: Graph,
-    top_level_expressions_map: HashMap<String, TopLevelExpressionIndex>   
+    top_level_expressions_map: HashMap<ClarityName, TopLevelExpressionIndex>   
 }
 
 impl AnalysisPass for DefinitionSorter {
@@ -58,11 +58,11 @@ impl <'a> DefinitionSorter {
         let sorted_indexes = walker.get_sorted_dependencies(&self.graph)?;
 
         if let Some(deps) = walker.get_cycling_dependencies(&self.graph, &sorted_indexes) {
-            let deps_props: Vec<(String, u64, &SymbolicExpression)> = deps.iter().map(|i| {
+            let deps_props: Vec<(_)> = deps.iter().map(|i| {
                 let exp = &contract_analysis.expressions[*i];
                 self.find_expression_definition(&exp).unwrap()
             }).collect();
-            let functions_names = deps_props.iter().map(|i| i.0.clone()).collect();
+            let functions_names = deps_props.iter().map(|i| i.0.to_string()).collect();
             let exprs = deps_props.iter().map(|i| i.2.clone()).collect();
 
             let mut error = CheckError::new(CheckErrors::CircularReference(functions_names));
@@ -194,7 +194,7 @@ impl <'a> DefinitionSorter {
     }
 
 
-    fn find_expression_definition<'b>(&mut self, exp: &'b SymbolicExpression) -> Option<(String, u64, &'b SymbolicExpression)> {
+    fn find_expression_definition<'b>(&mut self, exp: &'b SymbolicExpression) -> Option<(ClarityName, u64, &'b SymbolicExpression)> {
         let (_define_type, args) = DefineFunctions::try_parse(exp)?;
         let defined_name = match args.get(0)?.match_list() {
             Some(list) => list.get(0)?,

src/vm/analysis/mod.rs

@@ -10,6 +10,7 @@ pub mod build_contract_interface;
 
 use self::types::{ContractAnalysis, AnalysisPass};
 use vm::representations::{SymbolicExpression};
+use vm::types::{TypeSignature};
 
 pub use self::errors::{CheckResult, CheckError, CheckErrors};
 pub use self::analysis_db::{AnalysisDatabase};
@@ -20,11 +21,16 @@ use self::read_only_checker::ReadOnlyChecker;
 use self::type_checker::TypeChecker;
 
 #[cfg(test)]
-pub fn mem_type_check(snippet: &str) -> CheckResult<ContractAnalysis> {
+pub fn mem_type_check(snippet: &str) -> CheckResult<(Option<TypeSignature>, ContractAnalysis)> {
     use vm::parser::parse;
     let mut contract = parse(snippet).unwrap();
     let mut analysis_db = AnalysisDatabase::memory();
     type_check(&":transient:", &mut contract, &mut analysis_db, false)
+        .map(|x| {
+             // return the first type result of the type checker
+             let first_type = x.type_map.as_ref().unwrap()
+                .get_type(&x.expressions[0]).cloned();
+             (first_type, x) })
 }
 
 // Legacy function

src/vm/analysis/read_only_checker/mod.rs

@@ -1,4 +1,4 @@
-use vm::representations::{SymbolicExpression};
+use vm::representations::{SymbolicExpression, ClarityName};
 use vm::representations::SymbolicExpressionType::{AtomValue, Atom, List};
 use vm::types::{AtomTypeIdentifier, TypeSignature, TupleTypeSignature, parse_name_type_pairs};
 use vm::functions::NativeFunctions;
@@ -18,7 +18,7 @@ mod tests;
 
 pub struct ReadOnlyChecker <'a, 'b> {
     db: &'a mut AnalysisDatabase<'b>,
-    defined_functions: HashMap<String, bool>
+    defined_functions: HashMap<ClarityName, bool>
 }
 
 impl <'a, 'b> AnalysisPass for ReadOnlyChecker <'a, 'b> {
@@ -54,19 +54,20 @@ impl <'a, 'b> ReadOnlyChecker <'a, 'b> {
         Ok(())
     }
 
-    fn check_define_function(&mut self, args: &[SymbolicExpression]) -> CheckResult<(String, bool)> {
+    fn check_define_function(&mut self, args: &[SymbolicExpression]) -> CheckResult<(ClarityName, bool)> {
         check_argument_count(2, args)?;
 
         let signature = args[0].match_list()
             .ok_or(CheckErrors::DefineFunctionBadSignature)?;
         let body = &args[1];
 
-        let (function_name, _) = signature.split_first()
-            .ok_or(CheckErrors::DefineFunctionBadSignature)?;
+        let function_name = signature.get(0)
+            .ok_or(CheckErrors::DefineFunctionBadSignature)?
+            .match_atom().ok_or(CheckErrors::BadFunctionName)?;
 
         let is_read_only = self.is_read_only(body)?;
 
-        Ok((function_name.to_string(), is_read_only))
+        Ok((function_name.clone(), is_read_only))
     }
 
     fn check_reads_only_valid(&mut self, expr: &SymbolicExpression) -> CheckResult<()> {
@@ -248,7 +249,7 @@ impl <'a, 'b> ReadOnlyChecker <'a, 'b> {
             result
         } else {
             let is_function_read_only = self.defined_functions.get(function_name)
-                .ok_or(CheckErrors::UnknownFunction(function_name.clone()))?
+                .ok_or(CheckErrors::UnknownFunction(function_name.to_string()))?
                 .clone();
             self.are_all_read_only(is_function_read_only, args)
         }