Merge branch 'main' into feature/71-spacing-pending-rules

Author: jvsqzj

CHANGELOG.md

@@ -5,6 +5,10 @@
 # Change Log
 
 ## 0.9.13
+- Corrected the name of "explicit\_param\_decls" provisional. Note that it still
+  has no semantic effect.
+- The parameter declaration patterns ":=" and ": \<type\> = \<val\>" are now
+  correctly parsed.
 
 ## 0.9.12
 - Added 'simics\_util\_vect' as a known provisional (with no DLS semantics)

src/analysis/parsing/structure.rs

@@ -329,30 +329,22 @@ fn parse_method(modifier: Option<LeafToken>,
 
 #[derive(Debug, Clone, PartialEq)]
 pub enum ParamDef {
-    // Either default or =
+    // default | = <expr>
     Set(LeafToken, Expression),
     Auto(LeafToken),
-    Typed(LeafToken, CTypeDecl),
-    Empty,
 }
 
 impl TreeElement for ParamDef {
     fn range(&self) -> ZeroRange {
         match self {
             Self::Set(kw, expr) => Range::combine(kw.range(), expr.range()),
             Self::Auto(tok) => tok.range(),
-            Self::Typed(colon, typedecl) =>
-                Range::combine(colon.range(), typedecl.range()),
-            Self::Empty => ZeroRange::invalid(),
         }
     }
     fn subs(&self) -> TreeElements<'_> {
         match self {
             Self::Set(kw, expr) => create_subs!(kw, expr),
             Self::Auto(tok) => create_subs!(tok),
-            Self::Typed(colon, typedecl) =>
-                create_subs!(colon, typedecl),
-            Self::Empty => vec![],
         }
     }
 }
@@ -361,7 +353,9 @@ impl TreeElement for ParamDef {
 pub struct ParameterContent {
     pub param: LeafToken,
     pub name: LeafToken,
-    pub def: ParamDef,
+    pub colon: Option<LeafToken>,
+    pub typing: Option<CTypeDecl>,
+    pub def: Option<ParamDef>,
     pub semi: LeafToken,
 }
 
@@ -374,6 +368,8 @@ impl TreeElement for ParameterContent {
     fn subs(&self) -> TreeElements<'_> {
         create_subs!(&self.param,
                      &self.name,
+                     &self.colon,
+                     &self.typing,
                      &self.def,
                      &self.semi)
     }
@@ -385,23 +381,44 @@ impl Parse<DMLObjectContent> for ParameterContent {
         let param = inner.expect_next_kind(stream, TokenKind::Param);
         let name = inner.expect_next_filter(
             stream, objident_filter, "parameter name");
-        let def = match inner.peek_kind(stream) {
-            Some(TokenKind::Assign) | Some(TokenKind::Default) => {
-                let assign = inner.next_leaf(stream);
-                let value = Expression::parse(&inner, stream, file_info);
-                ParamDef::Set(assign, value)
-            },
-            Some(TokenKind::Auto) => ParamDef::Auto(inner.next_leaf(stream)),
-            Some(TokenKind::Colon) => {
-                let colon = inner.next_leaf(stream);
-                let typed = CTypeDecl::parse(&inner, stream, file_info);
-                ParamDef::Typed(colon, typed)
-            },
-            _ => ParamDef::Empty,
+        let colon = if inner.peek_kind(stream) == Some(TokenKind::Colon) {
+            Some(inner.next_leaf(stream))
+        } else {
+            None
+        };
+        fn parse_assign(context: &mut ParseContext,
+                        stream: &mut FileParser<'_>,
+                        file_info: &FileInfo) -> Option<ParamDef> {
+            match context.peek_kind(stream) {
+                Some(TokenKind::Assign) | Some(TokenKind::Default) => {
+                    let assign = context.next_leaf(stream);
+                    let value = Expression::parse(context, stream, file_info);
+                    Some(ParamDef::Set(assign, value))
+                },
+                Some(TokenKind::Auto) =>
+                    Some(ParamDef::Auto(context.next_leaf(stream))),
+                _ => None
+            }
+        }
+
+        let (typing, def) = match inner.peek_kind(stream) {
+            Some(TokenKind::Assign | TokenKind::Default | TokenKind::Auto) =>
+                (None, parse_assign(&mut inner, stream, file_info)),
+            _ if colon.is_some() =>
+                (Some(CTypeDecl::parse(&inner, stream, file_info)),
+                 if matches!(inner.peek_kind(stream),
+                             Some(TokenKind::Assign
+                                  | TokenKind::Default
+                                  | TokenKind::Auto)) {
+                     parse_assign(&mut inner, stream, file_info)
+                 } else {
+                     None
+                 }),
+            _ => (None, None),
         };
         let semi = outer.expect_next_kind(stream, TokenKind::SemiColon);
         DMLObjectContent::Parameter(ParameterContent {
-            param, name, def, semi
+            param, name, colon, typing, def, semi
         }).into()
     }
 }
@@ -719,7 +736,7 @@ fn check_dmlobject_kind(obj: &DMLObjectContent, _file: &TextFile) ->
         trace!("Checking kind restriction on {:?}", obj);
         match obj {
             DMLObjectContent::Parameter(paramcontent) => {
-                if let ParamDef::Typed(_, _) = &paramcontent.def {
+                if paramcontent.typing.is_some() {
                     return vec![LocalDMLError {
                         range: obj.range(),
                         description: "Typed parameter declaration only \

src/analysis/provisionals.rs

@@ -14,7 +14,7 @@ use crate::analysis::FileSpec;
 #[strum(serialize_all = "snake_case")]
 pub enum Provisional {
     // TODO: implement the neccessary checks for explicit params
-    ExplicitParamDecl,
+    ExplicitParamDecls,
     SimicsUtilVect,
 }
 
@@ -69,7 +69,7 @@ mod test {
     #[test]
     fn test_provisionals_parsing() {
         for (s, p) in [
-            ("explicit_param_decl", Provisional::ExplicitParamDecl),
+            ("explicit_param_decls", Provisional::ExplicitParamDecls),
             ("simics_util_vect", Provisional::SimicsUtilVect),
         ] {
             assert_eq!(Provisional::from_str(s), Ok(p));

src/analysis/structure/objects.rs

@@ -1132,24 +1132,26 @@ impl ToStructure<structure::ParameterContent> for Parameter {
     fn to_structure<'a>(content: &structure::ParameterContent,
                         report: &mut Vec<LocalDMLError>,
                         file: FileSpec<'a>) -> Option<Parameter> {
-        let (is_default, value, typed) = match &content.def {
-            structure::ParamDef::Set(assigntok, expr) => {
-                (assigntok.get_token()
-                 .map_or(false, |rt|rt.kind == TokenKind::Default),
-                 ExpressionKind::to_expression(expr, report, file).map(
-                     |e|ParamValue::Set(e)),
-                 None)
-            },
-            structure::ParamDef::Auto(tok) =>
-                (false,
-                 Some(ParamValue::Auto(ZeroSpan::from_range(tok.range(),
-                                                            file.path))),
-                 None),
-            structure::ParamDef::Typed(_, ty) =>
-                (false, None, to_type(ty, report, file)),
-            structure::ParamDef::Empty =>
-                (false, None, None),
-        };
+        // TODO: track whether this was a defining-declaration without type
+        // ("param foo := 1;") for purposes of checking when the provisional
+        // is activated
+        // TODO: We could consider warning here if ":=" syntax is used without
+        // provisional active?
+        let typed = content.typing.as_ref()
+            .and_then(|t|to_type(t, report, file));
+        let (is_default, value) = content.def.as_ref()
+            .map_or((false, None), |d| match d {
+                structure::ParamDef::Set(assigntok, expr) => {
+                    (assigntok.get_token()
+                     .map_or(false, |rt|rt.kind == TokenKind::Default),
+                     ExpressionKind::to_expression(expr, report, file).map(
+                         |e|ParamValue::Set(e)))
+                },
+                structure::ParamDef::Auto(tok) =>
+                    (false,
+                     Some(ParamValue::Auto(ZeroSpan::from_range(tok.range(),
+                                                                file.path)))),
+            });
         let object = DMLObjectCommon {
             name: DMLString::from_token(&content.name, file)?,
             span: ZeroSpan::from_range(content.range(), file.path),