`48f43d6`

Fix root CI regressions

Authored by mfwolffe <wolffemf@dukes.jmu.edu> 3 weeks ago

SHA: 48f43d634af91dc5c63b223a452051abf6c7b643
Parents: 54e88fa
Tree: 0a4bd08

5 changed files

Status	File	+	-
M	`src/ir/lower.rs`	24	13
M	`src/parser/unit.rs`	2	6
M	`src/sema/resolve.rs`	2	2
M	`src/sema/type_layout.rs`	4	4
M	`tests/licm_lsf_audit_29_11.rs`	35	2

src/ir/lower.rsmodified

  use std::io::Write;
  use std::rc::Rc;
 +type AmbiguousUseWarnings = Rc<RefCell<HashSet<(String, String, String)>>>;
++
  /// Maximum array rank (Fortran allows up to 15).
  const MAX_RANK: usize = 15;
      /// install_globals_as_locals. Large fortsh units can otherwise print the
      /// exact same ambiguity hundreds or thousands of times while lowering each
      /// contained procedure separately.
 -    ambiguous_use_warnings: Rc<RefCell<HashSet<(String, String, String)>>>,
 +    ambiguous_use_warnings: AmbiguousUseWarnings,
+ }
  impl<'a> LowerCtx<'a> {
          elemental_funcs: &'a HashSet<String>,
          char_len_star_params: &'a HashMap<String, Vec<bool>>,
          contained_host_refs: &'a HashMap<String, Vec<String>>,
 -        ambiguous_use_warnings: Rc<RefCell<HashSet<(String, String, String)>>>,
 +        ambiguous_use_warnings: AmbiguousUseWarnings,
      ) -> Self {
          Self {
              locals: HashMap::new(),
  ) -> (Module, HashMap<(String, String), ModuleGlobalInfo>) {
      let mut module = Module::new("main".into());
      let mut globals: HashMap<(String, String), ModuleGlobalInfo> = external_globals;
 -    let ambiguous_use_warnings: Rc<RefCell<HashSet<(String, String, String)>>> =
 -        Rc::new(RefCell::new(HashSet::new()));
 +    let ambiguous_use_warnings: AmbiguousUseWarnings = Rc::new(RefCell::new(HashSet::new()));
      // Pass 1: collect module-level variables.  Submodule decls are
      // installed under their parent module's name so the submodule's
      // names it reads or writes. Drives both callee signature
      // (hidden trailing pointer params) and call-site arg list.
      contained_host_refs: &HashMap<String, Vec<String>>,
 -    ambiguous_use_warnings: &Rc<RefCell<HashSet<(String, String, String)>>>,
 +    ambiguous_use_warnings: &AmbiguousUseWarnings,
      internal_only: bool,
  ) {
      match &unit.node {
      required_names: Option<&HashSet<String>>,
      host_module: Option<&str>,
      st: &SymbolTable,
 -    ambiguous_use_warnings: &Rc<RefCell<HashSet<(String, String, String)>>>,
 +    ambiguous_use_warnings: &AmbiguousUseWarnings,
  ) {
      use crate::ast::decl::OnlyItem;
                                                      vec![dest_ptr, dest_len, src_ptr, src_len],
                                                      IrType::Void,
                                                  );
 -                                                return;
+                                             }
+                                         }
+                                     }
                                                      vec![dest_ptr, dest_len, src_ptr, src_len],
                                                      IrType::Void,
                                                  );
 -                                                return;
+                                             }
+                                         }
+                                     }
                  if !tgt_field.pointer {
                      return;
+                 }
 -                if is_deferred_char_component_field(&tgt_field) {
 +                if is_deferred_char_component_field(tgt_field) {
                      if let Expr::FunctionCall { callee, .. } = &value.node {
                          if let Expr::Name { name } = &callee.node {
                              if name.eq_ignore_ascii_case("null") {
                  .filter(|info| local_is_array_like(info))
                  .cloned()
+         }
 -        Expr::ComponentAccess { .. } => component_intrinsic_local_info(b, locals, expr, st, type_layouts)
 -            .filter(|info| local_is_array_like(info)),
 +        Expr::ComponentAccess { .. } => component_intrinsic_local_info(
 +            b,
 +            locals,
 +            expr,
 +            st,
 +            type_layouts,
 +        )
 +        .filter(local_is_array_like),
          _ => None,
+     }
+ }
      tl: &crate::sema::type_layout::TypeLayoutRegistry,
  ) -> Option<LocalInfo> {
      let (field_ptr, field) = resolve_component_field_access(b, locals, expr, st, tl)?;
 -    if field.size == 384 && (field.allocatable || field.pointer) {
 +    if field_uses_array_descriptor(&field) {
          return Some(LocalInfo {
              addr: field_ptr,
              ty: field_storage_ir_type(&field, tl),
+     }
+ }
 +fn field_uses_array_descriptor(field: &crate::sema::type_layout::FieldLayout) -> bool {
 +    field.size == 384
 +        && (field.allocatable || field.pointer)
 +        && (field.declared_array || !field.dims.is_empty())
 +}
++
  fn component_array_local_info(
      b: &mut FuncBuilder,
      locals: &HashMap<String, LocalInfo>,
      tl: &crate::sema::type_layout::TypeLayoutRegistry,
  ) -> Option<LocalInfo> {
      let (field_ptr, field) = resolve_component_field_access(b, locals, expr, st, tl)?;
 -    if field.size != 384 || !(field.allocatable || field.pointer) {
 +    if !field_uses_array_descriptor(&field) {
          return None;
+     }
      Some(LocalInfo {

src/parser/unit.rsmodified

                          self.advance();
                      } // consume ::
                      let mut names = Vec::new();
 -                    loop {
 -                        if let Some(name) = self.parse_access_list_item()? {
 -                            names.push(name);
 -                        } else {
 -                            break;
 -                        }
 +                    while let Some(name) = self.parse_access_list_item()? {
 +                        names.push(name);
                          if !self.eat(&TokenKind::Comma) {
                              break;
+                         }

src/sema/resolve.rsmodified

  fn exported_const_int_params(
      st: &SymbolTable,
      scope_id: ScopeId,
 -    visible_cache: &mut HashMap<ScopeId, HashMap<String, i64>>,
 +    _visible_cache: &mut HashMap<ScopeId, HashMap<String, i64>>,
      exported_cache: &mut HashMap<ScopeId, HashMap<String, i64>>,
  ) -> HashMap<String, i64> {
      if let Some(cached) = exported_cache.get(&scope_id) {
              continue;
+         }
          for (name, value) in
 -            exported_const_int_params(st, assoc.source_scope, visible_cache, exported_cache)
 +            exported_const_int_params(st, assoc.source_scope, _visible_cache, exported_cache)
+         {
              out.entry(name).or_insert(value);
+         }

src/sema/type_layout.rsmodified

      match &expr.node {
          Expr::LogicalLiteral { value, .. } => Some(*value),
          Expr::ParenExpr { inner } => eval_const_logical_expr(inner),
 -        Expr::UnaryOp { op, operand } => match op {
 -            crate::ast::expr::UnaryOp::Not => eval_const_logical_expr(operand).map(|v| !v),
 -            _ => None,
 -        },
 +        Expr::UnaryOp {
 +            op: crate::ast::expr::UnaryOp::Not,
 +            operand,
 +        } => eval_const_logical_expr(operand).map(|v| !v),
          _ => None,
+     }
+ }

tests/licm_lsf_audit_29_11.rsmodified

      &func_section[start..end]
+ }
 +fn last_block_section<'a>(func_section: &'a str, prefix: &str) -> &'a str {
 +    let mut starts = Vec::new();
++
 +    for (idx, _line) in func_section.match_indices('\n') {
 +        let line_start = idx + 1;
 +        let tail = &func_section[line_start..];
 +        let line_text = tail.split_once('\n').map(|(line, _)| line).unwrap_or(tail);
 +        if line_text.starts_with("    ")
 +            && !line_text.starts_with("      ")
 +            && line_text[4..].starts_with(prefix)
 +        {
 +            starts.push(line_start);
 +        }
 +    }
++
 +    let start = *starts
 +        .last()
 +        .unwrap_or_else(|| panic!("missing block with prefix {}", prefix));
 +    let tail = &func_section[start..];
 +    let end = tail
 +        .match_indices('\n')
 +        .find_map(|(idx, _)| {
 +            let line_start = idx + 1;
 +            let rest = &tail[line_start..];
 +            let line_text = rest.split_once('\n').map(|(line, _)| line).unwrap_or(rest);
 +            ((line_text.starts_with("    ") && !line_text.starts_with("      "))
 +                || line_text == "  }")
 +                .then_some(idx)
 +        })
 +        .unwrap_or(tail.len());
 +    &tail[..end]
 +}
++
  fn tail_after<'a>(text: &'a str, needle: &str) -> &'a str {
      let start = text
          .find(needle)
      let raw_branchy = function_section(&raw_ir, helper_names[2]);
      let opt_branchy = function_section(&opt_ir, helper_names[2]);
 -    let raw_join = block_section(raw_branchy, "if_end_9");
 -    let opt_join = block_section(opt_branchy, "if_end_9");
 +    let raw_join = last_block_section(raw_branchy, "if_end_");
 +    let opt_join = last_block_section(opt_branchy, "if_end_");
      assert!(
          raw_join.contains("gep") && raw_join.contains("load"),