org.snapscript.tree.reference.GenericDeclaration Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of snap-all Show documentation
Dynamic scripting for the JVM
There is a newer version: 1.4.6
package org.snapscript.tree.reference;

import static org.snapscript.core.constraint.Constraint.OBJECT;
import static org.snapscript.core.variable.Value.NULL;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

import org.snapscript.core.Evaluation;
import org.snapscript.core.constraint.Constraint;
import org.snapscript.core.constraint.TypeParameterConstraint;
import org.snapscript.core.error.InternalStateException;
import org.snapscript.core.module.Module;
import org.snapscript.core.scope.Scope;
import org.snapscript.core.trace.Trace;
import org.snapscript.core.trace.TraceInterceptor;
import org.snapscript.core.type.Type;
import org.snapscript.core.variable.Value;
import org.snapscript.tree.constraint.TypeConstraint;

public class GenericDeclaration { 

   private final ConstraintCompilation compilation;
   private final GenericArgumentList generics;
   private final TypeReference reference; 
   private final Set imports;
   
   public GenericDeclaration(TypeReference reference, GenericArgumentList generics, TraceInterceptor interceptor, Trace trace) {
      this.compilation = new ConstraintCompilation(reference, generics, interceptor, trace);
      this.imports = new HashSet();
      this.reference = reference;
      this.generics = generics;
   }
   
   public Value declare(Scope scope) throws Exception {
      Module module = scope.getModule();
      Scope outer = module.getScope();
      String name = reference.qualify(scope, null);  
      
      if(generics != null) {
         List other = generics.getImports(scope);
         
         if(other != null) {
            imports.addAll(other);
         }
      }         
      if(name != null) {
         imports.add(name);
      }
      return new ConstraintConstant(compilation, outer, imports);
   }
   
   private static class ConstraintCompilation extends Evaluation {

      private final TraceInterceptor interceptor;
      private final GenericArgumentList generics;
      private final TypeReference reference;
      private final Trace trace;

      public ConstraintCompilation(TypeReference reference, GenericArgumentList generics, TraceInterceptor interceptor, Trace trace) {
         this.interceptor = interceptor;
         this.reference = reference;
         this.generics = generics;
         this.trace = trace;
      }

      @Override
      public Constraint compile(Scope scope, Constraint left) { 
         try {
            Value value = reference.evaluate(scope, NULL);
            Object object = value.getValue();

            if(Type.class.isInstance(object)) {
               Constraint constraint = value.getConstraint();
               String name = constraint.getName(scope);
               Type type = constraint.getType(scope);
               
               if(generics != null) {
                  List arguments = generics.getGenerics(scope);    
                  
                  if(!arguments.isEmpty()) {
                     return new TypeParameterConstraint(type, arguments, name);
                  }
               }
               return new TypeParameterConstraint(type, name);
            }
            return value.getConstraint();
         }catch(Exception cause) {
            interceptor.traceCompileError(scope, trace, cause);
         }
         return OBJECT;
      }   
   }  
   
   private static class ConstraintConstant extends Value {
      
      private final Constraint constraint;
      private final Scope scope;
      
      public ConstraintConstant(Evaluation evaluation, Scope scope, Set imports) {
         this.constraint = new ConstraintEvaluation(evaluation, imports);
         this.scope = scope;        
      }
      
      @Override
      public boolean isConstant() {
         return true;
      }
      
      @Override
      public Constraint getConstraint() {
         return constraint;
      }
      
      @Override
      public  T getValue() {
         return (T)constraint.getType(scope);            
      }
      
      @Override
      public void setValue(Object value){
         throw new InternalStateException("Illegal modification of literal '" + value + "'");
      } 
      
      @Override
      public String toString() {
         return String.valueOf(constraint);
      }
   }   
   
   private static class ConstraintEvaluation extends Constraint {
         
      private final Constraint constraint;
      private final List imports; 
      
      public ConstraintEvaluation(Evaluation evaluation, Set imports) {
         this.constraint = new TypeConstraint(evaluation);
         this.imports = new ArrayList(imports);      
      }     
      
      @Override
      public boolean isConstant() {
         return true;
      }
      
      @Override
      public List getImports(Scope scope) {
         return imports;
      }
      
      @Override
      public String getName(Scope scope) {
         return constraint.getName(scope);
      }

      @Override
      public List getGenerics(Scope scope) {
         return constraint.getGenerics(scope);
      }
      
      @Override
      public Type getType(Scope scope) {
         return constraint.getType(scope);
      }  
      
      @Override
      public String toString() {
         return String.valueOf(constraint);
      }
   }
}