Aprimoramento no loop for

[PeCMay2105]

Responsáveis:

Inácio Leal e Pedro Cortez Maia

Técnicas utilizadas: Pair programming, Extreme Programming e programação funcional.

#O objetivo principal das mudanças é adicionar suporte para strings e tuplas em loops for
#Em adição melhoramos o escopo variavel do loop

O que foi alterado:

Estende a funcionalidade do loop for para iterar sobre strings e tuplas homogêneas, além do suporte existente para listas.

Motivo

• Expressividade limitada: Apenas listas eram iteráveis, restringindo casos de uso comuns
• Conflitos de escopo: Variáveis iteradoras compartilhavam escopo com variáveis externas, causando potenciais conflitos de nomenclatura
• Lacunas de type safety: Faltava validação para homogeneidade de tuplas e consistência de tipos de iteradores

Como

Type Checker (statement_type_checker.rs)

• Adicionada função get_iterable_element_type() para centralizar validação de tipos iteráveis
• Refatorada check_for_stmt() para usar escopo adequado com push()/pop()
• Melhorada validação de tipos para strings e tuplas homogêneas

Runtime (statement_execute.rs)

• Estendido case Statement::For para tratar Expression::CString e Expression::Tuple
• Melhoradas mensagens de erro para tipos não suportados
• Mantido comportamento consistente de escopo entre todos os tipos iteráveis

Mudanças

Iteráveis Suportados

• ✅ TList<T> - funcionalidade existente preservada
• ✅ TString - itera sobre caracteres como strings individuais
• ✅ TTuple<T> - apenas tuplas homogêneas, tuplas heterogêneas rejeitadas em tempo de compilação

Escopo da Variável do loop for:

• Variáveis iteradoras agora têm escopo isolado dentro do loop
• Sem conflitos com variáveis externas de mesmo nome
• Variáveis retornam ao escopo original após conclusão do loop

Testando

// Iteração sobre string
for ch in "hello" { ... }

// Iteração sobre tupla homogênea
for num in (1, 2, 3) { ... }

// Isolamento de escopo
let x = "externa";
for x in [1, 2, 3] {
    // x é Integer aqui
}
// x é "externa" novamente

Breaking Changes

• Nenhum: Código existente com loop for continua funcionando inalterado
• Tempo de compilação: Tuplas heterogêneas como (1, "hello", true) agora são adequadamente rejeitadas com mensagens de erro claras

Arquivos Modificados

• src/type_checker/statement_type_checker.rs
• src/interpreter/statement_execute.rs

[PeCMay2105]

Parte adicionada por Pedro Maia:

`Statement::For(var, expr, stmt) => {
let coll = eval(*expr, &new_env)?;

match coll {
    // Lista de valores
    Expression::ListValue(items) => {
        new_env.push();
        for item in items {
            new_env.map_variable(var.clone(), true, item);
            new_env = execute(*stmt.clone(), &new_env)?;
        }
        new_env.pop();
        Ok(new_env)
    }
    
    // String - itera sobre caracteres
    Expression::CString(s) => {
        new_env.push();
        for ch in s.chars() {
            let char_value = Expression::CString(ch.to_string());
            new_env.map_variable(var.clone(), true, char_value);
            new_env = execute(*stmt.clone(), &new_env)?;
        }
        new_env.pop();
        Ok(new_env)
    }
    
    // Tupla (assumindo que você tem Expression::Tuple)
    Expression::Tuple(items) => {
        new_env.push();
        for item in items {
            new_env.map_variable(var.clone(), true, item);
            new_env = execute(*stmt.clone(), &new_env)?;
        }
        new_env.pop();
        Ok(new_env)
    }
    
    // Constructor (já existia)
    Expression::Constructor(_, items) => {
        new_env.push();
        for item_expr in items {
            let item_value = *item_expr.clone();
            new_env.map_variable(var.clone(), true, item_value);
            new_env = execute(*stmt.clone(), &new_env)?;
        }
        new_env.pop();
        Ok(new_env)
    }
    
    _ => Err((format!("Cannot iterate over {:?}", coll), None)),
}

}
// Função auxiliar para determinar o tipo do elemento iterável
fn get_iterable_element_type(expr_type: &Type) -> Result<Type, ErrorMessage> {
match expr_type {
Type::TList(base_type) => Ok((**base_type).clone()),
Type::TString => Ok(Type::TString), // Caracteres como strings
Type::TTuple(types) => {
if types.is_empty() {
return Err("[Type Error] Cannot iterate over empty tuple type".to_string());
}

        // Verificar se todos os tipos são iguais (tupla homogênea)
        let first_type = &types[0];
        if types.iter().all(|t| t == first_type) {
            Ok(first_type.clone())
        } else {
            Err("[Type Error] Can only iterate over homogeneous tuples (all elements same type)".to_string())
        }
    }
    _ => Err(format!("[Type Error] Type {:?} is not iterable", expr_type))
}

}

fn check_for_stmt(
var: Name,
expr: Box,
stmt: Box,
env: &Environment,
) -> Result<Environment, ErrorMessage> {
let mut new_env = env.clone();

// Avaliar o tipo da expressão iterável
let expr_type = check_expr(*expr, &new_env)?;

// Determinar o tipo do elemento
let element_type = get_iterable_element_type(&expr_type)?;

// Criar novo escopo para o loop
new_env.push();

// Mapear a variável iteradora no novo escopo
new_env.map_variable(var.clone(), false, element_type);

// Verificar o corpo do loop no novo escopo
new_env = check_stmt(*stmt, &new_env)?;

// Remover o escopo do loop
new_env.pop();

Ok(new_env)

}`