codemodels-java 0.2.0-java

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+coverage
+InstalledFiles
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+
+# YARD artifacts
+.yardoc
+_yardoc
+doc/
+Gemfile.lock

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE

@@ -0,0 +1,198 @@
+Eclipse Public License - v 1.0
+
+THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE PUBLIC
+LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR DISTRIBUTION OF THE PROGRAM
+CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS AGREEMENT.
+
+1. DEFINITIONS
+
+"Contribution" means:
+
+a) in the case of the initial Contributor, the initial code and documentation
+   distributed under this Agreement, and
+b) in the case of each subsequent Contributor:
+    i) changes to the Program, and
+   ii) additions to the Program;
+
+   where such changes and/or additions to the Program originate from and are
+   distributed by that particular Contributor. A Contribution 'originates' from
+   a Contributor if it was added to the Program by such Contributor itself or
+   anyone acting on such Contributor's behalf. Contributions do not include
+   additions to the Program which: (i) are separate modules of software
+   distributed in conjunction with the Program under their own license
+   agreement, and (ii) are not derivative works of the Program.
+
+"Contributor" means any person or entity that distributes the Program.
+
+"Licensed Patents" mean patent claims licensable by a Contributor which are
+necessarily infringed by the use or sale of its Contribution alone or when
+combined with the Program.
+
+"Program" means the Contributions distributed in accordance with this Agreement.
+
+"Recipient" means anyone who receives the Program under this Agreement,
+including all Contributors.
+
+2. GRANT OF RIGHTS
+  a) Subject to the terms of this Agreement, each Contributor hereby grants
+     Recipient a non-exclusive, worldwide, royalty-free copyright license to
+     reproduce, prepare derivative works of, publicly display, publicly perform,
+     distribute and sublicense the Contribution of such Contributor, if any, and
+     such derivative works, in source code and object code form.
+  b) Subject to the terms of this Agreement, each Contributor hereby grants
+     Recipient a non-exclusive, worldwide, royalty-free patent license under
+     Licensed Patents to make, use, sell, offer to sell, import and otherwise
+     transfer the Contribution of such Contributor, if any, in source code and
+     object code form. This patent license shall apply to the combination of the
+     Contribution and the Program if, at the time the Contribution is added by
+     the Contributor, such addition of the Contribution causes such combination
+     to be covered by the Licensed Patents. The patent license shall not apply
+     to any other combinations which include the Contribution. No hardware per
+     se is licensed hereunder.
+  c) Recipient understands that although each Contributor grants the licenses to
+     its Contributions set forth herein, no assurances are provided by any
+     Contributor that the Program does not infringe the patent or other
+     intellectual property rights of any other entity. Each Contributor
+     disclaims any liability to Recipient for claims brought by any other entity
+     based on infringement of intellectual property rights or otherwise. As a
+     condition to exercising the rights and licenses granted hereunder, each
+     Recipient hereby assumes sole responsibility to secure any other
+     intellectual property rights needed, if any. For example, if a third party
+     patent license is required to allow Recipient to distribute the Program, it
+     is Recipient's responsibility to acquire that license before distributing
+     the Program.
+  d) Each Contributor represents that to its knowledge it has sufficient
+     copyright rights in its Contribution, if any, to grant the copyright
+     license set forth in this Agreement.
+
+3. REQUIREMENTS
+
+A Contributor may choose to distribute the Program in object code form under its
+own license agreement, provided that:
+
+  a) it complies with the terms and conditions of this Agreement; and
+  b) its license agreement:
+      i) effectively disclaims on behalf of all Contributors all warranties and
+         conditions, express and implied, including warranties or conditions of
+         title and non-infringement, and implied warranties or conditions of
+         merchantability and fitness for a particular purpose;
+     ii) effectively excludes on behalf of all Contributors all liability for
+         damages, including direct, indirect, special, incidental and
+         consequential damages, such as lost profits;
+    iii) states that any provisions which differ from this Agreement are offered
+         by that Contributor alone and not by any other party; and
+     iv) states that source code for the Program is available from such
+         Contributor, and informs licensees how to obtain it in a reasonable
+         manner on or through a medium customarily used for software exchange.
+
+When the Program is made available in source code form:
+
+  a) it must be made available under this Agreement; and
+  b) a copy of this Agreement must be included with each copy of the Program.
+     Contributors may not remove or alter any copyright notices contained within
+     the Program.
+
+Each Contributor must identify itself as the originator of its Contribution, if
+any, in a manner that reasonably allows subsequent Recipients to identify the
+originator of the Contribution.
+
+4. COMMERCIAL DISTRIBUTION
+
+Commercial distributors of software may accept certain responsibilities with
+respect to end users, business partners and the like. While this license is
+intended to facilitate the commercial use of the Program, the Contributor who
+includes the Program in a commercial product offering should do so in a manner
+which does not create potential liability for other Contributors. Therefore, if
+a Contributor includes the Program in a commercial product offering, such
+Contributor ("Commercial Contributor") hereby agrees to defend and indemnify
+every other Contributor ("Indemnified Contributor") against any losses, damages
+and costs (collectively "Losses") arising from claims, lawsuits and other legal
+actions brought by a third party against the Indemnified Contributor to the
+extent caused by the acts or omissions of such Commercial Contributor in
+connection with its distribution of the Program in a commercial product
+offering. The obligations in this section do not apply to any claims or Losses
+relating to any actual or alleged intellectual property infringement. In order
+to qualify, an Indemnified Contributor must: a) promptly notify the Commercial
+Contributor in writing of such claim, and b) allow the Commercial Contributor to
+control, and cooperate with the Commercial Contributor in, the defense and any
+related settlement negotiations. The Indemnified Contributor may participate in
+any such claim at its own expense.
+
+For example, a Contributor might include the Program in a commercial product
+offering, Product X. That Contributor is then a Commercial Contributor. If that
+Commercial Contributor then makes performance claims, or offers warranties
+related to Product X, those performance claims and warranties are such
+Commercial Contributor's responsibility alone. Under this section, the
+Commercial Contributor would have to defend claims against the other
+Contributors related to those performance claims and warranties, and if a court
+requires any other Contributor to pay any damages as a result, the Commercial
+Contributor must pay those damages.
+
+5. NO WARRANTY
+
+EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS PROVIDED ON AN
+"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR
+IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE,
+NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each
+Recipient is solely responsible for determining the appropriateness of using and
+distributing the Program and assumes all risks associated with its exercise of
+rights under this Agreement , including but not limited to the risks and costs
+of program errors, compliance with applicable laws, damage to or loss of data,
+programs or equipment, and unavailability or interruption of operations.
+
+6. DISCLAIMER OF LIABILITY
+
+EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT NOR ANY
+CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST
+PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS
+GRANTED HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+
+7. GENERAL
+
+If any provision of this Agreement is invalid or unenforceable under applicable
+law, it shall not affect the validity or enforceability of the remainder of the
+terms of this Agreement, and without further action by the parties hereto, such
+provision shall be reformed to the minimum extent necessary to make such
+provision valid and enforceable.
+
+If Recipient institutes patent litigation against any entity (including a
+cross-claim or counterclaim in a lawsuit) alleging that the Program itself
+(excluding combinations of the Program with other software or hardware)
+infringes such Recipient's patent(s), then such Recipient's rights granted under
+Section 2(b) shall terminate as of the date such litigation is filed.
+
+All Recipient's rights under this Agreement shall terminate if it fails to
+comply with any of the material terms or conditions of this Agreement and does
+not cure such failure in a reasonable period of time after becoming aware of
+such noncompliance. If all Recipient's rights under this Agreement terminate,
+Recipient agrees to cease use and distribution of the Program as soon as
+reasonably practicable. However, Recipient's obligations under this Agreement
+and any licenses granted by Recipient relating to the Program shall continue and
+survive.
+
+Everyone is permitted to copy and distribute copies of this Agreement, but in
+order to avoid inconsistency the Agreement is copyrighted and may only be
+modified in the following manner. The Agreement Steward reserves the right to
+publish new versions (including revisions) of this Agreement from time to time.
+No one other than the Agreement Steward has the right to modify this Agreement.
+The Eclipse Foundation is the initial Agreement Steward. The Eclipse Foundation
+may assign the responsibility to serve as the Agreement Steward to a suitable
+separate entity. Each new version of the Agreement will be given a
+distinguishing version number. The Program (including Contributions) may always
+be distributed subject to the version of the Agreement under which it was
+received. In addition, after a new version of the Agreement is published,
+Contributor may elect to distribute the Program (including its Contributions)
+under the new version. Except as expressly stated in Sections 2(a) and 2(b)
+above, Recipient receives no rights or licenses to the intellectual property of
+any Contributor under this Agreement, whether expressly, by implication,
+estoppel or otherwise. All rights in the Program not expressly granted under
+this Agreement are reserved.
+
+This Agreement is governed by the laws of the State of New York and the
+intellectual property laws of the United States of America. No party to this
+Agreement will bring a legal action under this Agreement more than one year
+after the cause of action arose. Each party waives its rights to a jury trial in
+any resulting litigation.

data/README.md

@@ -0,0 +1,6 @@
+codemodels-java
+===============
+
+Plugin of codemodels to build models from Java code.
+
+See http://github.com/ftomassetti/codemodels

data/Rakefile

@@ -0,0 +1,13 @@
+require 'rake/testtask'
+require 'rubygems/tasks'
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+end
+
+Gem::Tasks.new do |tasks|
+  tasks.console.command = 'jruby'
+end
+
+desc "Run tests"
+task :default => :test

data/codemodels-java.gemspec

@@ -0,0 +1,24 @@
+Gem::Specification.new do |s|
+  s.platform    = 'java'
+  s.name        = 'codemodels-java'
+  s.version     = '0.2.0'
+  s.date        = '2013-09-11'
+  s.summary     = "Plugin of codemodels to build models from Ruby code."
+  s.description = "Plugin of codemodels to build models from Ruby code. See http://github.com/ftomassetti/codemodels."
+  s.authors     = ["Federico Tomassetti"]
+  s.email       = 'f.tomassetti@gmail.com'
+  s.homepage    = 'https://github.com/ftomassetti/java-lightmodels'
+  s.license     = "APACHE2"
+  s.files         = `git ls-files`.split($/)
+  s.executables   = s.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  s.test_files    = s.files.grep(%r{^(test|spec|features)/})
+  s.require_paths = ["lib"] + Dir['./lib/jars/*.jar']
+
+  s.add_runtime_dependency 'codemodels'
+  s.add_runtime_dependency 'json'
+
+  s.add_development_dependency "bundler", "~> 1.3"
+  s.add_development_dependency "rake"  
+  s.add_development_dependency "simplecov"
+  s.add_development_dependency "rubygems-tasks"
+end

data/lib/codemodels/java/info_extraction.rb

@@ -0,0 +1,110 @@
+module CodeModels
+
+module Java
+
+module InfoExtraction
+
+def self.is_camel_case_str(s)
+	not s.index /[^A-Za-z0-9]/
+end
+
+def self.camel_to_words(camel)
+	return [''] if camel==''
+
+	# if camel contains an upcase word and it is followed by something then
+	# extract it and process the camel before and after
+	# to understand where the upcase word ends we have to look if there is
+	# a downcase char after
+	upcaseword_index = camel.index /[A-Z]{2}/
+	number_index = camel.index /[0-9]/
+	if upcaseword_index
+		if upcaseword_index==0
+			words_before = []
+		else
+			camel_before = camel[0..upcaseword_index-1]
+			words_before = camel_to_words(camel_before)
+		end
+
+		camel_from = camel[upcaseword_index..-1]
+		has_other_after = camel_from.index /[^A-Z]/		
+		if has_other_after
+			is_lower_case_after = camel_from[has_other_after].index /[a-z]/
+			if is_lower_case_after
+				mod = 1
+			else
+				mod = 0
+			end
+			upcase_word = camel_from[0..has_other_after-1-mod]
+			camel_after = camel_from[has_other_after-mod..-1]
+			words_after = camel_to_words(camel_after)
+		else
+			upcase_word = camel_from
+			words_after = []
+		end
+		words = words_before
+		words << upcase_word
+		words = words + words_after
+		words
+	elsif number_index
+		if number_index==0
+			words_before = []
+		else
+			camel_before = camel[0..number_index-1]
+			words_before = camel_to_words(camel_before)
+		end
+
+		camel_from = camel[number_index..-1]
+		has_other_after = camel_from.index /[^0-9]/
+		if has_other_after
+			number_word = camel_from[0..has_other_after-1]
+			camel_after = camel_from[has_other_after..-1]
+			words_after = camel_to_words(camel_after)
+		else
+			number_word = camel_from
+			words_after = []
+		end
+		words = words_before
+		words << number_word
+		words = words + words_after
+		words		
+	else
+		camel.split /(?=[A-Z])/
+	end    
+end
+
+class JavaSpecificInfoExtractionLogic
+	
+	def terms_containing_value?(value)
+		CodeModels::Java::InfoExtraction.is_camel_case_str(value)
+	end
+
+	def to_words(value)
+		res = ::CodeModels::Java::InfoExtraction.camel_to_words(value)
+		res.each {|v| raise "Camel case to words produced a nil" if v==nil}
+		raise "No words found using the camel case to words" if res.count==0		
+		res
+	end
+
+	def concat(a,b)
+		a+b
+	end
+
+end
+
+end # end of InfoExtraction
+
+module JavaInfoExtractionFunctionalities
+
+	def terms_map(context=nil)
+		super(InfoExtraction::JavaSpecificInfoExtractionLogic.new,context)
+	end
+
+end
+
+class JavaNode
+	include JavaInfoExtractionFunctionalities
+end
+
+end
+
+end

data/lib/codemodels/java/java_models_builder.rb

@@ -0,0 +1,17 @@
+require 'json'
+require 'codemodels/java/model_building'
+require 'codemodels'
+
+$PWD = File.dirname(__FILE__)
+
+raise "Usage: java_models_builder <sources> <models>" unless ARGV.count==2
+
+sources_path = ARGV[0]
+models_path = ARGV[1]
+raise "Path to sources does not exist or it is not a dir: #{sources_path}" unless File.exist?(sources_path) and File.directory?(sources_path)
+raise "Path to models does not exist or it is not a dir: #{models_path}" unless File.exist?(models_path) and File.directory?(models_path)
+
+$SRC  = sources_path
+$DEST = models_path
+
+CodeModels::Java.generate_java_models_in_dir($SRC,$DEST)

data/lib/codemodels/java/language.rb

@@ -0,0 +1,17 @@
+require 'codemodels'
+
+module CodeModels
+module Java
+
+class JavaLanguage < Language
+	def initialize
+		super('Java')
+		@extensions << 'java'
+		@parser = CodeModels::Java::Parser.new
+	end
+end
+
+CodeModels.register_language JavaLanguage.new
+
+end
+end

data/lib/codemodels/java/metamodel.rb

@@ -0,0 +1,234 @@
+require 'rgen/metamodel_builder'
+require 'java'
+require 'codemodels'
+
+module CodeModels
+module Java
+
+	class JavaNode < RGen::MetamodelBuilder::MMBase
+	end
+
+	JavaString  = ::Java::JavaClass.for_name("java.lang.String")
+	JavaList    = ::Java::JavaClass.for_name("java.util.List")
+	JavaBoolean = ::Java::boolean.java_class
+	JavaInt = ::Java::int.java_class
+	JapaMethodDeclaration = ::Java::JavaClass.for_name("japa.parser.ast.body.MethodDeclaration")
+
+	MappedAstClasses = {}
+
+	def self.wrap(ast_names)		
+
+		# first create all the classes
+		ast_names.each do |ast_name|
+			java_class = ::Java::JavaClass.for_name("japa.parser.ast.#{ast_name}")
+			java_super_class = java_class.superclass
+			if java_super_class.name == 'japa.parser.ast.Node'
+				super_class = JavaNode
+			else
+				raise "Super class #{java_super_class.name} of #{java_class.name}. It should be wrapped before!" unless MappedAstClasses[java_super_class]
+				super_class = MappedAstClasses[java_super_class]
+			end
+			#puts "Java Super Class: #{java_super_class.name}"
+			ast_class = java_class.ruby_class
+			# TODO it should extend the right class...
+			c = Class.new(super_class)
+			raise "Already mapped! #{ast_name}" if MappedAstClasses[java_class]
+			MappedAstClasses[java_class] = c
+			Java.const_set simple_java_class_name(ast_class), c
+		end
+
+		# then add all the properties and attributes
+		ast_names.each do |ast_name|
+			java_class = ::Java::JavaClass.for_name("japa.parser.ast.#{ast_name}")
+			ast_class = java_class.ruby_class
+			c = MappedAstClasses[java_class]
+
+			props_to_ignore = ['modifiers','arrayCount','operator','comments','javaDoc','varArgs','interface']
+				
+			c.class_eval do
+				ast_class.java_class.declared_instance_methods.select {|m| m.name.start_with?('get')||m.name.start_with?('is') }.each do |m|
+					prop_name = CodeModels::Java.property_name(m)
+					unless props_to_ignore.include?(prop_name)
+						if m.return_type==JavaString
+							has_attr prop_name, String
+						elsif m.return_type==JavaBoolean
+							has_attr prop_name, RGen::MetamodelBuilder::DataTypes::Boolean
+						elsif m.return_type==JavaInt
+							has_attr prop_name, Integer
+						elsif MappedAstClasses.has_key?(m.return_type)
+							contains_one_uni prop_name, MappedAstClasses[m.return_type]
+						elsif m.return_type==JavaList
+		#					puts "Property #{prop_name} is a list"
+							type_name = CodeModels::Java.get_generic_param(m.to_generic_string)
+							last = type_name.index '>'
+							type_name = type_name[0..last-1]
+							type_ast_class = MappedAstClasses.keys.find{|k| k.name==type_name}
+							if type_ast_class
+								contains_many_uni prop_name, MappedAstClasses[type_ast_class]
+							else
+								raise "#{ast_name}) Property (many) #{prop_name} is else: #{type_name}"
+							end
+						elsif m.return_type.enum?
+							has_attr prop_name, String
+						else
+							raise "#{ast_name}) Property (single) #{prop_name} is else: #{m.return_type}"
+						end
+					end
+					#type = nil
+					#contains_one_uni prop_name, type
+				end
+			end
+		end
+	end
+
+	def self.get_corresponding_metaclass(node)
+		node_class = node.class
+		name = simple_java_class_name(node_class)
+		name = "#{(node.operator.name).proper_capitalize}BinaryExpr" if name=='BinaryExpr'
+		#puts "node.class: #{node.class}"
+		if node.class.to_s=='Java::JapaParserAstBody::MethodDeclaration'
+			if node.parent.class.to_s=='Java::JapaParserAstExpr::ObjectCreationExpr'
+				# ObjectCreationExpr has not interface? but it is always a method definition
+				name = 'ClassMethodDeclaration'
+			elsif node.parent.class.to_s=='Java::JapaParserAstBody::EnumDeclaration'
+				name = 'ClassMethodDeclaration' 
+			elsif node.parent.interface?				
+				name = 'InterfaceMethodDeclaration'
+			else
+				name = 'ClassMethodDeclaration'
+			end
+		end
+		return Java.const_get(name)
+	end
+
+	PROP_ADAPTERS = Hash.new {|h,k| h[k] = {} }
+
+	private
+
+	def self.property_name(java_method)
+		return java_method.name.remove_prefix('get').proper_uncapitalize if java_method.name.start_with?('get')
+		return java_method.name.remove_prefix('is').proper_uncapitalize if java_method.name.start_with?('is')
+	end
+
+	def self.simple_java_class_name(java_class)
+		name = java_class.name
+    	if (i = (r = name).rindex(':')) then r[0..i] = '' end
+    	r
+  	end
+
+  	def self.get_generic_param(generic_str)
+  		return generic_str.remove_prefix('public java.util.List<') if generic_str.start_with?('public java.util.List<')
+  		return generic_str.remove_prefix('public final java.util.List<') if generic_str.start_with?('public final java.util.List<')
+  		nil
+  	end
+
+  	wrap [
+  		'Comment',
+  		'BlockComment',  		
+  		'LineComment',
+  		'ImportDeclaration',
+  		'CompilationUnit',
+	  	'TypeParameter',
+	  	'PackageDeclaration',
+	  	
+	  	'body.BodyDeclaration',	  	
+	  	'body.TypeDeclaration',
+  		'body.AnnotationDeclaration',
+  		'body.AnnotationMemberDeclaration',
+	  	'body.JavadocComment',	  	
+  		'body.VariableDeclaratorId',
+	  	'body.Parameter',
+	  	'body.MethodDeclaration',
+	  	'body.ClassOrInterfaceDeclaration',
+	  	'body.EmptyMemberDeclaration',
+	  	'body.EmptyTypeDeclaration',
+	  	'body.EnumConstantDeclaration',
+	  	'body.EnumDeclaration',
+	  	'body.FieldDeclaration',
+	  	'body.InitializerDeclaration',
+	  	'body.ConstructorDeclaration',
+	  	'body.VariableDeclarator',
+
+  		'expr.Expression',
+  		'expr.NameExpr',  		
+	  	'expr.AnnotationExpr',
+		'expr.ArrayAccessExpr',
+		'expr.ArrayCreationExpr',
+		'expr.ArrayInitializerExpr',
+		'expr.AssignExpr',
+		'expr.BinaryExpr',
+		'expr.LiteralExpr',
+		'expr.BooleanLiteralExpr',
+		'expr.CastExpr',
+		'expr.StringLiteralExpr',
+		'expr.CharLiteralExpr',
+		'expr.ClassExpr',
+		'expr.ConditionalExpr',
+		'expr.DoubleLiteralExpr',
+		'expr.EnclosedExpr',
+		'expr.FieldAccessExpr',
+		'expr.InstanceOfExpr',
+		'expr.IntegerLiteralExpr',
+		'expr.IntegerLiteralMinValueExpr',
+		'expr.LongLiteralExpr',
+		'expr.LongLiteralMinValueExpr',
+		'expr.MarkerAnnotationExpr',
+		'expr.MemberValuePair',
+		'expr.MethodCallExpr',
+		'expr.NormalAnnotationExpr',
+		'expr.NullLiteralExpr',
+		'expr.ObjectCreationExpr',
+		'expr.QualifiedNameExpr',
+		'expr.SingleMemberAnnotationExpr',
+		'expr.SuperExpr',
+		'expr.ThisExpr',
+		'expr.UnaryExpr',
+		'expr.VariableDeclarationExpr',
+
+	  	'stmt.Statement',
+	  	'stmt.BlockStmt',
+		'stmt.AssertStmt',
+		'stmt.BreakStmt',
+		'stmt.CatchClause',
+		'stmt.ContinueStmt',
+		'stmt.DoStmt',
+		'stmt.EmptyStmt',
+		'stmt.ExplicitConstructorInvocationStmt',
+		'stmt.ExpressionStmt',
+		'stmt.ForeachStmt',
+		'stmt.ForStmt',
+		'stmt.IfStmt',
+		'stmt.LabeledStmt',
+		'stmt.ReturnStmt',
+		'stmt.SwitchEntryStmt',
+		'stmt.SwitchStmt',
+		'stmt.SynchronizedStmt',
+		'stmt.ThrowStmt',
+		'stmt.TryStmt',
+		'stmt.TypeDeclarationStmt',
+		'stmt.WhileStmt',
+
+	  	'type.Type',
+	  	'type.ClassOrInterfaceType',
+	  	'type.PrimitiveType',
+	  	'type.ReferenceType',
+	  	'type.VoidType',
+	  	'type.WildcardType' ]
+
+	['Or','And','BinOr','BinAnd', 'Xor',
+		'Equals','NotEquals',
+		'Less','Greater','LessEquals','GreaterEquals',
+		'LShift','RSignedShift','RUnsignedShift',
+		'Plus', 'Minus', 'Times','Divide','Remainder'].each do |op|
+		c = Class.new(BinaryExpr)
+		Java.const_set "#{op}BinaryExpr", c
+	end
+	
+	class InterfaceMethodDeclaration < MethodDeclaration
+	end
+
+	class ClassMethodDeclaration < MethodDeclaration
+	end
+
+end
+end