• Home
• org.gosu-lang.gosu
• gosu-lab
• 1.17.7
• source code
• Compiler.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

editor.shipit.Compiler Maven / Gradle / Ivy

package editor.shipit;

import editor.FileTree;
import editor.NodeKind;
import editor.MessageTree;
import editor.MessagesPanel;
import editor.settings.CompilerSettings;
import editor.util.IProgressCallback;
import gw.util.StreamUtil;
import java.io.File;
import java.nio.file.Path;
import gw.util.PathUtil;
import gw.lang.parser.GosuParserFactory;
import gw.lang.parser.IFileRepositoryBasedType;
import gw.lang.parser.IHasInnerClass;
import gw.lang.parser.IParseIssue;
import gw.lang.parser.exceptions.ParseResultsException;
import gw.lang.reflect.IType;
import gw.lang.reflect.ITypeRef;
import gw.lang.reflect.TypeSystem;
import gw.lang.reflect.gs.IGosuClass;

import gw.lang.reflect.java.IJavaType;
import java.awt.*;
import java.io.IOException;
import java.io.OutputStream;
import java.util.*;
import javax.tools.Diagnostic;
import javax.tools.DiagnosticCollector;
import javax.tools.JavaFileObject;
import manifold.internal.javac.IJavaParser;

/**
 */
public class Compiler
{
  private MessageTree _warnings;
  private int _iWarnings = 0;
  private MessageTree _errors;
  private int _iErrors = 0;
  private MessageTree _failures;
  private int _iFailures = 0;

  public boolean compileTree( FileTree tree, ICompileConsumer consumer, IProgressCallback progress, MessagesPanel messagesPanel )
  {
    if( progress.isAbort() )
    {
      return false;
    }

    if( tree.isFile() )
    {
      IType type = tree.getType();
      progress.incrementProgress( type != null ? type.getName() : "" );
      if( type instanceof IFileRepositoryBasedType )
      {
        if( !compile( type, consumer, messagesPanel ) )
        {
          return false;
        }
      }
    }
    else if( tree.isDirectory() )
    {
      for( FileTree file: tree.getChildren() )
      {
        if( !compileTree( file, consumer, progress, messagesPanel ) )
        {
          return false;
        }
      }
    }
    return true;
  }

  public int getWarnings()
  {
    return _iWarnings;
  }

  public int getErrors()
  {
    return _iErrors;
  }

  public int getFailures()
  {
    return _iFailures;
  }

  private void addWarnings( ParseResultsException parseException )
  {
    _iWarnings += parseException.getParseWarnings().size();
  }

  private void addErrors( ParseResultsException parseException )
  {
    _iErrors += parseException.getParseExceptions().size();
  }

  private void addFailure()
  {
    _iFailures++;
  }

  private void updateMessageTree( MessagesPanel messages )
  {
    EventQueue.invokeLater( () -> {
      if( _iWarnings > 0 )
      {
        if( _warnings == null )
        {
          _warnings = new MessageTree( "", NodeKind.Info, MessageTree.empty() );
          messages.appendToTop( _warnings );
        }
        _warnings.setText( "Warnings: " + _iWarnings );
      }

      if( _iErrors > 0 )
      {
        if( _errors == null )
        {
          _errors = new MessageTree( "", NodeKind.Info, MessageTree.empty() );
          messages.appendToTop( _errors );
        }
        _errors.setText( "Errors: " + _iErrors );
      }

      if( _iFailures > 0 )
      {
        if( _failures == null )
        {
          _failures = new MessageTree( "", NodeKind.Info, MessageTree.empty() );
          messages.appendToTop( _failures );
        }
        _failures.setText( "Failures: " + _iFailures );
      }
    } );
  }

  public boolean compile( IType type, ICompileConsumer consumer, MessagesPanel messages )
  {
    //## todo: provide a plugin interface for type compiler

    if( type instanceof IGosuClass )
    {
      return compileGosu( (IGosuClass)type, consumer, messages );
    }
    if( type instanceof IJavaType )
    {
      return compileJava( (IJavaType)type, consumer, messages );
    }

    return true;
  }

  private boolean compileGosu( IGosuClass gsClass, ICompileConsumer consumer, MessagesPanel messages )
  {
    if( isExcluded( gsClass ) )
    {
      return true;
    }

    //
    // Parse
    //
    parseImpl( gsClass );
    //noinspection ThrowableResultOfMethodCallIgnored
    ParseResultsException parseException = gsClass.getParseResultsException();

    if( parseException != null && !parseException.hasOnlyParseWarnings() )
    {
      addWarnings( parseException );
      addErrors( parseException );
      EventQueue.invokeLater( () -> {
        updateMessageTree( messages );
        MessageTree typeNode = messages.addTypeMessage( gsClass.getName(), null, MessageTree.empty() );
        parseException.getParseWarnings().forEach( warning -> messages.addWarningMessage( makeIssueMessage( warning, NodeKind.Warning ), typeNode, MessageTree.makeIssueMessage( warning ) ) );
        parseException.getParseExceptions().forEach( error -> messages.addErrorMessage( makeIssueMessage( error, NodeKind.Error ), typeNode, MessageTree.makeIssueMessage( error ) ) );
      } );

      // Parse Errors, return now
      return consumer.accept( new CompiledClass( gsClass, null ) );
    }

    //
    // Compile
    //
    try
    {
      if( parseException != null && parseException.getParseIssues().size() > 0 )
      {
        addWarnings( parseException );
        EventQueue.invokeLater( () -> {
          updateMessageTree( messages );
          MessageTree typeNode = messages.addTypeMessage( gsClass.getName(), null, MessageTree.empty() );
          parseException.getParseWarnings().forEach( warning -> messages.addWarningMessage( makeIssueMessage( warning, NodeKind.Warning ), typeNode, MessageTree.makeIssueMessage( warning ) ) );
        } );
      }

      return compileClass( gsClass, consumer );
    }
    catch( Exception e )
    {
      //
      // Failure
      //
      addFailure();
      EventQueue.invokeLater( () -> {
        updateMessageTree( messages );
        MessageTree typeNode = messages.addTypeMessage( gsClass.getName(), null, MessageTree.empty() );
        messages.addFailureMessage( e.getMessage(), typeNode, MessageTree.empty() );
        e.printStackTrace();
      } );
      return consumer.accept( new CompiledClass( gsClass, null ) );
    }
  }

  private boolean compileJava( IJavaType javaType, ICompileConsumer consumer, MessagesPanel messages )
  {
    if( isExcluded( javaType ) )
    {
      return true;
    }

    IJavaParser javaParser = GosuParserFactory.getInterface( IJavaParser.class );
    DiagnosticCollector errorHandler = new DiagnosticCollector<>();
    javaParser.compile( javaType.getName(), Arrays.asList( "-g", "-Xlint:unchecked", "-parameters" ), errorHandler );
    boolean errant = errorHandler.getDiagnostics().stream().anyMatch( e -> e.getKind() == Diagnostic.Kind.ERROR );
    if( errant )
    {
      errorHandler.getDiagnostics().forEach(
        e ->
        {
          switch( e.getKind() )
          {
            case ERROR:
              _iErrors++;
              break;
            case WARNING:
            case MANDATORY_WARNING:
              _iWarnings++;
              break;
          }
        } );
      EventQueue.invokeLater( () -> {
        updateMessageTree( messages );
        MessageTree typeNode = messages.addTypeMessage( javaType.getName(), null, MessageTree.empty() );
        errorHandler.getDiagnostics().forEach(
          e ->
          {
            switch( e.getKind() )
            {
              case ERROR:
                messages.addErrorMessage( makeIssueMessage( e, NodeKind.Error ), typeNode, MessageTree.makeIssueMessage( e, javaType ) );
                break;
              case WARNING:
              case MANDATORY_WARNING:
                messages.addWarningMessage( makeIssueMessage( e, NodeKind.Warning ), typeNode, MessageTree.makeIssueMessage( e, javaType ) );
                break;
            }
          } );
      } );

      // Parse Errors, return now
      return consumer.accept( new CompiledClass( javaType, null ) );
    }

    //
    // Compile
    //
    try
    {
      if( errorHandler.getDiagnostics().stream().anyMatch( e -> e.getKind() == Diagnostic.Kind.WARNING || e.getKind() == Diagnostic.Kind.MANDATORY_WARNING ) )
      {
        errorHandler.getDiagnostics().forEach(
          e ->
          {
            switch( e.getKind() )
            {
              case WARNING:
              case MANDATORY_WARNING:
                _iWarnings++;
                break;
            }
          } );
        EventQueue.invokeLater( () -> {
          updateMessageTree( messages );
          MessageTree typeNode = messages.addTypeMessage( javaType.getName(), null, MessageTree.empty() );
          errorHandler.getDiagnostics().forEach(
            e ->
            {
              switch( e.getKind() )
              {
                case WARNING:
                case MANDATORY_WARNING:
                  messages.addWarningMessage( makeIssueMessage( e, NodeKind.Warning ), typeNode, MessageTree.makeIssueMessage( e, javaType ) );
                  break;
              }
            } );
        } );
      }

      return compileClass( javaType, consumer );
    }
    catch( Exception e )
    {
      //
      // Failure
      //
      addFailure();
      EventQueue.invokeLater( () -> {
        updateMessageTree( messages );
        MessageTree typeNode = messages.addTypeMessage( javaType.getName(), null, MessageTree.empty() );
        messages.addFailureMessage( e.getMessage(), typeNode, MessageTree.empty() );
        e.printStackTrace();
      } );
      return consumer.accept( new CompiledClass( javaType, null ) );
    }
  }

  private boolean isExcluded( IType type )
  {
    //## todo: expose "Excluded" in Lab so users can exclude stuff

    if( type.getRelativeName().startsWith( "Errant_" ) )
    {
      return true;
    }

    if( type instanceof IGosuClass )
    {
      IGosuClass gsClass = (IGosuClass)type;
      if( gsClass.getSource().contains( "@DoNotVerifyResource" ) )
      {
        return true;
      }
    }

    return false;
  }

  private String makeIssueMessage( IParseIssue issue, NodeKind kind )
  {
    String msg = kind == NodeKind.Warning ? "Warning: " : "Error: ";
    msg += "(" + issue.getLine() + ", " + issue.getColumn() + ") " + issue.getPlainMessage();
    return msg;
  }

  private String makeIssueMessage( Diagnostic issue, NodeKind kind )
  {
    String msg = kind == NodeKind.Error ? "Error: " : "Warning: ";
    msg += "(" + issue.getLineNumber() + ", " + issue.getColumnNumber() + ") " + issue.getMessage( Locale.getDefault() );
    return msg;
  }

  private boolean compileClass( IFileRepositoryBasedType type, ICompileConsumer consumer )
  {
    if( !type.isCompilable() )
    {
      // For instance, a JavaSourceUnresolvedClass is not ocmpilable;
      // this happens if the Java source file doesn't have a class in it matching the name of the file
      return true;
    }

    byte[] bytes = type.compile();
    if( !consumer.accept( new CompiledClass( type, bytes ) ) )
    {
      return false;
    }
    makeClassFile( type, bytes );
    if( type instanceof IHasInnerClass )
    {
      for( IType innerClass : ((IHasInnerClass)type).getInnerClasses() )
      {
        if( !compileClass( (IFileRepositoryBasedType)innerClass, consumer ) )
        {
          return false;
        }
      }
    }
    return true;
  }

  private void makeClassFile( IFileRepositoryBasedType type, byte[] bytes )
  {
    if( !CompilerSettings.isStaticCompile() )
    {
      return;
    }

    Path outputDir = CompilerSettings.getCompilerOutputDir();
    if( !PathUtil.exists( outputDir ) )
    {
      if( !PathUtil.mkdirs( outputDir ) || !PathUtil.isDirectory( outputDir ) )
      {
        return;
      }
    }

    String javaName = type.getJavaName();
    javaName = javaName.replace( '.', File.separatorChar ) + ".class";
    Path classFile = PathUtil.create( outputDir, javaName );
    //noinspection ResultOfMethodCallIgnored
    PathUtil.mkdirs( classFile.getParent() );
    try( OutputStream writer = PathUtil.createOutputStream( classFile ) )
    {
      writer.write( bytes );
    }
    catch( IOException e )
    {
      throw new RuntimeException( e );
    }

    copySourceFile( type, outputDir );
  }

  private void copySourceFile( IFileRepositoryBasedType type, Path outputDir )
  {
    if( !(type instanceof IJavaType) && type.getEnclosingType() == null )
    {
      File file = type.getSourceFileHandle().getFile().toJavaFile();
      File toDir = new File( outputDir.toFile(), type.getNamespace().replace( '.', File.separatorChar ) );
      //noinspection ResultOfMethodCallIgnored
      toDir.mkdirs();
      StreamUtil.copy( file, toDir );
    }
  }

  protected void parseImpl( IGosuClass gsClass )
  {
    TypeSystem.lock();
    try
    {
      if( gsClass != null )
      {
        TypeSystem.refresh( (ITypeRef)gsClass );
        gsClass.setCreateEditorParser( false );
        gsClass.isValid(); // force compilation
      }
    }
    finally
    {
      TypeSystem.unlock();
    }
  }
}