adiciona atribuicao se nulo e null coalescing

Author: nathaliafab

Imperativa1/src/li1/plp/expressions2/expression/ExpNullCoalescing.java

@@ -0,0 +1,75 @@
+package li1.plp.expressions2.expression;
+
+import li1.plp.expressions1.util.Tipo;
+import li1.plp.expressions1.util.TipoPrimitivo;
+import li1.plp.expressions1.util.TipoOptional;
+import li1.plp.expressions2.memory.AmbienteCompilacao;
+import li1.plp.expressions2.memory.AmbienteExecucao;
+import li1.plp.expressions2.memory.VariavelJaDeclaradaException;
+import li1.plp.expressions2.memory.VariavelNaoDeclaradaException;
+
+public class ExpNullCoalescing extends ExpBinaria {
+
+    public ExpNullCoalescing(Expressao esq, Expressao dir) {
+        super(esq, dir, "??");
+    }
+
+    @Override
+    public Valor avaliar(AmbienteExecucao amb) throws VariavelNaoDeclaradaException, VariavelJaDeclaradaException {
+        Valor valorEsq = getEsq().avaliar(amb);
+
+		// Se o valor da expressão da esquerda for nulo, retorna o valor da expressão da direita
+        if (valorEsq instanceof ValorNulo) {
+            return getDir().avaliar(amb);
+        }
+        return valorEsq;
+    }
+
+    @Override
+    protected boolean checaTipoElementoTerminal(AmbienteCompilacao ambiente)
+            throws VariavelNaoDeclaradaException, VariavelJaDeclaradaException {
+        Tipo tipoEsq = getEsq().getTipo(ambiente);
+        Tipo tipoDir = getDir().getTipo(ambiente);
+
+		// Se a expressão da esquerda for do tipo nulo, a expressão da direita deve ser válida
+        if (tipoEsq.getNome().equals("NULO")) {
+            return tipoDir.eValido();
+        }
+
+        if (tipoEsq instanceof TipoOptional) {
+            Tipo base = ((TipoOptional) tipoEsq).getBaseType();
+            
+			// Se a base do tipo opcional for nula, o resultado é válido se a expressão da direita for válida
+            if (base == null || base.getNome().equals("NULO")) {
+                return tipoDir.eValido();
+            }
+            
+			// Se a base do tipo opcional for diferente de nulo, o resultado é válido se a base for igual ao tipo da expressão da direita
+            return base.getNome().equals(tipoDir.getNome());
+        }
+        
+		// Se a expressão da esquerda não for nula nem opcional, os tipos devem ser iguais
+        return tipoEsq.eIgual(tipoDir);
+    }
+
+    @Override
+    public Tipo getTipo(AmbienteCompilacao ambiente) throws VariavelNaoDeclaradaException, VariavelJaDeclaradaException {
+        Tipo tipoEsq = getEsq().getTipo(ambiente);
+        Tipo tipoDir = getDir().getTipo(ambiente);
+
+        if (tipoEsq instanceof TipoOptional) {
+            Tipo base = ((TipoOptional) tipoEsq).getBaseType();
+            if (base != null && !base.getNome().equals("NULO")) {
+                return base;
+            }
+        }
+        
+		// Se a expressão da esquerda for do tipo nulo, o tipo resultante é o tipo da expressão da direita
+        return tipoDir;
+    }
+
+    @Override
+    public ExpBinaria clone() {
+        return new ExpNullCoalescing(getEsq().clone(), getDir().clone());
+    }
+}

Imperativa1/src/li1/plp/imperative1/command/AtribuicaoSeNulo.java

@@ -0,0 +1,51 @@
+package li1.plp.imperative1.command;
+
+import li1.plp.expressions2.expression.Expressao;
+import li1.plp.expressions2.expression.Id;
+import li1.plp.expressions2.expression.ValorNulo;
+import li1.plp.expressions2.memory.VariavelJaDeclaradaException;
+import li1.plp.expressions2.memory.VariavelNaoDeclaradaException;
+import li1.plp.imperative1.memory.AmbienteCompilacaoImperativa;
+import li1.plp.imperative1.memory.AmbienteExecucaoImperativa;
+
+public class AtribuicaoSeNulo implements Comando {
+
+    private Id id;
+    private Expressao expressao;
+
+    public AtribuicaoSeNulo(Id id, Expressao expressao) {
+        this.id = id;
+        this.expressao = expressao;
+    }
+
+    public AmbienteExecucaoImperativa executar(
+            AmbienteExecucaoImperativa ambiente)
+            throws VariavelJaDeclaradaException, VariavelNaoDeclaradaException {
+        // só atribui se o valor atual for nulo
+        if (ambiente.get(id) instanceof ValorNulo) {
+            ambiente.changeValor(id, expressao.avaliar(ambiente));
+        }
+        return ambiente;
+    }
+
+    public boolean checaTipo(AmbienteCompilacaoImperativa ambiente)
+            throws VariavelNaoDeclaradaException, VariavelJaDeclaradaException {
+        boolean isExpNull = expressao.getTipo(ambiente).eIgual(li1.plp.expressions1.util.TipoPrimitivo.NULO);
+        boolean isIdOptional = id.getTipo(ambiente) instanceof li1.plp.expressions1.util.TipoOptional;
+        
+        if (isExpNull && !isIdOptional) {
+            return false;
+        }
+        if (isExpNull && isIdOptional) {
+            return expressao.checaTipo(ambiente);
+        }
+        
+        boolean ok = expressao.checaTipo(ambiente)
+                && id.getTipo(ambiente).eIgual(expressao.getTipo(ambiente));
+                
+        if (!ok) {
+            System.out.println("Atribuicao Null-Aware falhou o checaTipo! id type: " + id.getTipo(ambiente).getNome() + ", exp type: " + expressao.getTipo(ambiente).getNome());
+        }
+        return ok;
+    }
+}

Imperativa1/src/li1/plp/imperative1/parser/Imperative1.jj

@@ -253,6 +253,11 @@ TOKEN : /* OPERATORS */
 | < REM: "%" >
 }
 
+TOKEN : /* NOVO: NULL-AWARE OPERATORS */
+{
+  < NULL_COALESCING: "??" >
+| < NULL_AWARE_ASSIGN: "?:=" >
+}
 
 Programa Input() :
 { 
@@ -652,6 +657,8 @@ Expressao PExpressao() :
 	(
 	    LOOKAHEAD (PExpBase() <HOOK>) 
 			retorno = PExpTernaria()
+	  | LOOKAHEAD (PExpBase() <NULL_COALESCING>)
+	        retorno = PExpNullCoalescing()
 	  |
 	    retorno = PExpBase()
 	)
@@ -660,6 +667,18 @@ Expressao PExpressao() :
 	}
 }
 
+ExpNullCoalescing PExpNullCoalescing() :
+{
+	Expressao esq;
+	Expressao dir;
+}
+{
+	esq = PExpBase()
+	<NULL_COALESCING>
+	dir = PExpressao()
+	{return new ExpNullCoalescing(esq, dir);}
+}
+
 /*  ADICIONADO OU MODIFICADO DA Imperativa1 PARA A Imperativa2  */
 
 Comando PComandoSimples() :
@@ -669,6 +688,7 @@ Comando PComandoSimples() :
 {
     (
     	retorno = PSkip()
+      | LOOKAHEAD(PId() <NULL_AWARE_ASSIGN>) retorno = PAtribuicaoSeNulo()
       | retorno = PAtribuicao()
       | retorno = PComandoDeclaracao()
       | retorno = PWhile()
@@ -681,6 +701,16 @@ Comando PComandoSimples() :
     }
 }
 
+AtribuicaoSeNulo PAtribuicaoSeNulo() :
+{
+	Id id;
+	Expressao exp;
+}
+{
+	id = PId() <NULL_AWARE_ASSIGN> exp = PExpressao()
+	{ return new AtribuicaoSeNulo(id, exp); }
+}
+
 ComandoDeclaracao PComandoDeclaracao() :
 {
 	Declaracao dec;

README.md

@@ -32,7 +32,7 @@ Para rodar todos os testes automatizados da pasta `Testes` e visualizar os resul
 
 # Escopo
 
-Esse projeto tem como objetivo adicionar à [Linguagem Imperativa 1](https://augustosampaio.github.io/PLP/linguagens/imperativa1) o operador Null, a capacidade de Null safety, e operadores presentes em linguagens modernas que estão relacionados ao conceito de Null ("??", "!", "??="), além do operador ternário.
+Esse projeto tem como objetivo adicionar à [Linguagem Imperativa 1](https://augustosampaio.github.io/PLP/linguagens/imperativa1) o operador Null, a capacidade de Null safety, e operadores presentes em linguagens modernas que estão relacionados ao conceito de Null ("??", "!", "?:="), além do operador ternário.
 
 Abaixo temos o que será implementado pela linguagem em mais detalhes:
 
@@ -79,19 +79,18 @@ Abaixo temos o que será implementado pela linguagem em mais detalhes:
   ```
 
 
-- [ ] **Null coalescing:** Operador binário ("??") que retorna o lado direito da operação caso o operador seja null, ou o esquerdo caso não seja null. Valor "default".
+- [x] **Null coalescing:** Operador binário ("??") que retorna o lado direito da operação caso o operador seja null, ou o esquerdo caso não seja null. Valor "default".
 
   Exemplo:
   ```java
-  { var optional y = 2 ;
-    { var x = y ?? 3 ;
-      write(x)
-    }
+  {
+   var optional y = null,
+   var x = y ?? 5;
+   write(x)
   }
-  // y pode ser null (nesse caso tem um valor)
-  // Caso y seja null, x recebe 3
-  // Caso não, x recebe y, que é 2
-  // x vale 2
+  // y pode ser null (nesse caso é null)
+  // x é o valor de y caso y não seja null, ou 5 caso y seja null
+  // x vale 5
   ```
 
 - [x] **Operador Ternário:** Operador "? :" que atua como um if-then-else.
@@ -132,17 +131,18 @@ Abaixo temos o que será implementado pela linguagem em mais detalhes:
   // x é o valor de y (aqui tomado como não-nulo) + 2
   // erro de execução por tentar acessar um valor que é nulo
   ```
-- [ ] **Operador de atribuição Se Nulo (Null-Aware Assignment Operator):** operador binário ("??=") que atribui um valor ao lado esquerdo se, e somente se, esse valor for nulo. Na prática, seria um *shadowing* condicional.
+- [x] **Operador de atribuição Se Nulo (Null-Aware Assignment Operator):** operador binário ("?:=") que atribui um valor ao lado esquerdo se, e somente se, esse valor for nulo. Na prática, seria um *shadowing* condicional.
 
   Exemplo:
   ```java
-  { var optional y = null ;
-    y ??= 5 ;
-    y ??= 10 ;
-    write(y)
+  {
+   var optional y = null;
+   y ?:= 5;
+   y ?:= 10;
+   write(y)
   }
   // Declaramos uma variável como possivelmente nula
-  // Atribuímos 5 a ela, já que ela é nula
+  // Atribuímos a ela o valor 5, já que ela é nula
   // Como a variável agora tem um valor (5), ela não recebe 10
   // y vale 5
   ```
@@ -164,7 +164,7 @@ Skip ::=
 
 Atribuicao ::= Id “:=” Expressao
 
-AtribuicaoSeNulo := Id "??=" Expressao
+AtribuicaoSeNulo := Id "?:=" Expressao
 
 Expressao ::= Valor
        | ExpUnaria

Testes/NULL_AWARE_ASSIGN_variable_different_types.txt

@@ -0,0 +1,8 @@
+expect: Erro de tipo
+
+{
+   var optional y = 3;
+   y ?:= true;
+   y ?:= false;
+   write(y)
+}

Testes/NULL_AWARE_ASSIGN_variable_with_value.txt

@@ -0,0 +1,8 @@
+expect: 3
+
+{
+   var optional y = 3;
+   y ?:= 5;
+   y ?:= 10;
+   write(y)
+}

Testes/NULL_AWARE_ASSIGN_variable_without_value.txt

@@ -0,0 +1,8 @@
+expect: 5
+
+{
+   var optional y = null;
+   y ?:= 5;
+   y ?:= 10;
+   write(y)
+}

Testes/NULL_COALESCING_variable_different_types.txt

@@ -0,0 +1,7 @@
+expect: Erro de tipo
+
+{
+   var optional y = true,
+   var x = y ?? 5;
+   write(x)
+}

Testes/NULL_COALESCING_variable_with_value_non_optional.txt

@@ -0,0 +1,7 @@
+expect: 2
+
+{
+   var y = 2,
+   var x = y ?? 5;
+   write(x)
+}

Testes/NULL_COALESCING_variable_with_value_optional.txt

@@ -0,0 +1,7 @@
+expect: 3
+
+{
+   var optional y = 3,
+   var x = y ?? 5;
+   write(x)
+}